Changeset 25956


Ignore:
Timestamp:
01/27/21 16:14:34 (4 years ago)
Author:
Eric.Larour
Message:

CHG: changing sea level rise to sea level change. Mostly cosmetic.

Location:
issm/trunk-jpl
Files:
1 added
2 deleted
55 edited

Legend:

Unmodified
Added
Removed

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

    r25947 r25956  
    758758if ANDROID
    759759if ANDROIDEXE
    760 bin_PROGRAMS = issm issm_slr
     760bin_PROGRAMS = issm issm_slc
    761761else
    762762bin_PROGRAMS =
    … …  
    766766bin_PROGRAMS =
    767767else
    768 bin_PROGRAMS = issm issm_slr
     768bin_PROGRAMS = issm issm_slc
    769769endif
    770770endif
    … …  
    786786issm_CXXFLAGS= $(CXXFLAGS) $(CXXOPTFLAGS)
    787787
    788 issm_slr_SOURCES = main/issm_slr.cpp
    789 issm_slr_CXXFLAGS= $(CXXFLAGS) $(CXXOPTFLAGS)
     788issm_slc_SOURCES = main/issm_slc.cpp
     789issm_slc_CXXFLAGS= $(CXXFLAGS) $(CXXOPTFLAGS)
    790790
    791791if OCEAN

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

    r25947 r25956  
    2424        int geodetic=0;
    2525        int dslmodel=0;
    26         int externalnature=0;
    2726        int isexternal=0;
    2827
    … …  
    171170        int         dslmodel=0;
    172171        int         externalnature=0;
     172        int         isexternal=0;
    173173
    174174        IssmDouble* G_rigid = NULL;
    … …  
    198198        IssmDouble*  partitionice=NULL;
    199199        IssmDouble*  partitionhydro=NULL;
    200         IssmDouble*  bslrice_partition=NULL;
    201         IssmDouble*  bslrhydro_partition=NULL;
     200        IssmDouble*  bslcice_partition=NULL;
     201        IssmDouble*  bslchydro_partition=NULL;
    202202        int          npartice,nparthydro,nel;
    203203
    … …  
    206206        parameters->AddObject(iomodel->CopyConstantObject("md.dsl.model",DslModelEnum));
    207207        parameters->AddObject(iomodel->CopyConstantObject("md.solidearth.isexternal",SolidearthIsExternalEnum));
    208         parameters->AddObject(iomodel->CopyConstantObject("md.solidearth.external.nature",SolidearthExternalNatureEnum));
     208        iomodel->FetchData(&isexternal,"md.solidearth.isexternal");
     209        if(isexternal) parameters->AddObject(iomodel->CopyConstantObject("md.solidearth.external.nature",SolidearthExternalNatureEnum));
    209210        parameters->AddObject(iomodel->CopyConstantObject("md.solidearth.settings.runfrequency",SolidearthSettingsRunFrequencyEnum));
    210211        parameters->AddObject(iomodel->CopyConstantObject("md.solidearth.settings.reltol",SolidearthSettingsReltolEnum));
    … …  
    223224        parameters->AddObject(iomodel->CopyConstantObject("md.solidearth.planetradius",SolidearthPlanetRadiusEnum));
    224225        parameters->AddObject(iomodel->CopyConstantObject("md.solidearth.settings.glfraction",SolidearthSettingsGlfractionEnum));
    225         parameters->AddObject(new DoubleParam(CumBslrEnum,0.0));
    226         parameters->AddObject(new DoubleParam(CumBslrIceEnum,0.0));
    227         parameters->AddObject(new DoubleParam(CumBslrHydroEnum,0.0));
    228         parameters->AddObject(new DoubleParam(CumGmtslrEnum,0.0));
     226        parameters->AddObject(new DoubleParam(CumBslcEnum,0.0));
     227        parameters->AddObject(new DoubleParam(CumBslcIceEnum,0.0));
     228        parameters->AddObject(new DoubleParam(CumBslcHydroEnum,0.0));
     229        parameters->AddObject(new DoubleParam(CumGmtslcEnum,0.0));
    229230
    230231        /*compute planet area and plug into parameters:*/
    … …  
    240241                parameters->AddObject(new DoubleMatParam(SolidearthPartitionIceEnum,partitionice,nel,1));
    241242                parameters->AddObject(iomodel->CopyConstantObject("md.solidearth.npartice",SolidearthNpartIceEnum));
    242                 bslrice_partition=xNewZeroInit<IssmDouble>(npartice);
    243                 parameters->AddObject(new DoubleMatParam(CumBslrIcePartitionEnum,bslrice_partition,npartice,1));
     243                bslcice_partition=xNewZeroInit<IssmDouble>(npartice);
     244                parameters->AddObject(new DoubleMatParam(CumBslcIcePartitionEnum,bslcice_partition,npartice,1));
    244245                xDelete<IssmDouble>(partitionice);
    245246        }
    … …  
    250251                parameters->AddObject(new DoubleMatParam(SolidearthPartitionHydroEnum,partitionhydro,nel,1));
    251252                parameters->AddObject(iomodel->CopyConstantObject("md.solidearth.nparthydro",SolidearthNpartHydroEnum));
    252                 bslrhydro_partition=xNewZeroInit<IssmDouble>(nparthydro);
    253                 parameters->AddObject(new DoubleMatParam(CumBslrHydroPartitionEnum,bslrhydro_partition,nparthydro,1));
     253                bslchydro_partition=xNewZeroInit<IssmDouble>(nparthydro);
     254                parameters->AddObject(new DoubleMatParam(CumBslcHydroPartitionEnum,bslchydro_partition,nparthydro,1));
    254255                xDelete<IssmDouble>(partitionhydro);
    255256        }
    … …  
    274275        } /*}}}*/
    275276        /*Deal with external multi-model ensembles: {{{*/
    276         iomodel->FetchData(&externalnature,"md.solidearth.external.nature");
    277         if(externalnature>=3){
    278                 IssmDouble modelid;
    279                 int nummodels;
    280                
    281                 /*create double param, not int param, because Dakota will be updating it as a double potentially: */
    282                 iomodel->FetchData(&modelid,"md.solidearth.external.modelid");
    283                 parameters->AddObject(new DoubleParam(SolidearthExternalModelidEnum,modelid));
    284                 parameters->AddObject(iomodel->CopyConstantObject("md.solidearth.external.nummodels",SolidearthExternalNummodelsEnum));
    285                 iomodel->FetchData(&nummodels,"md.solidearth.external.nummodels");
    286 
    287                 /*quick checks: */
    288                 if(nummodels<=0)_error_("mme solidearth solution object in  md.solidearth.external field should contain at least 1 ensemble model!");
    289                 if(modelid<=0 || modelid>nummodels)_error_("modelid field in md.solidearth.external field should be between 1 and the number of ensemble runs!");
    290         } /*}}}*/
     277        if(isexternal){
     278                iomodel->FetchData(&externalnature,"md.solidearth.external.nature");
     279                if(externalnature>=3){
     280                        IssmDouble modelid;
     281                        int nummodels;
     282
     283                        /*create double param, not int param, because Dakota will be updating it as a double potentially: */
     284                        iomodel->FetchData(&modelid,"md.solidearth.external.modelid");
     285                        parameters->AddObject(new DoubleParam(SolidearthExternalModelidEnum,modelid));
     286                        parameters->AddObject(iomodel->CopyConstantObject("md.solidearth.external.nummodels",SolidearthExternalNummodelsEnum));
     287                        iomodel->FetchData(&nummodels,"md.solidearth.external.nummodels");
     288
     289                        /*quick checks: */
     290                        if(nummodels<=0)_error_("mme solidearth solution object in  md.solidearth.external field should contain at least 1 ensemble model!");
     291                        if(modelid<=0 || modelid>nummodels)_error_("modelid field in md.solidearth.external field should be between 1 and the number of ensemble runs!");
     292                } /*}}}*/
     293        }
    291294
    292295        /*Deal with elasticity {{{*/

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

    r25947 r25956  
    58265826
    58275827        /*output: */
    5828         IssmDouble bslrice=0;
     5828        IssmDouble bslcice=0;
    58295829
    58305830        /*elastic green function:*/
    … …  
    58425842                constant=0; this->AddInput(SealevelBarystaticMaskEnum,&constant,P0Enum);
    58435843                #endif
    5844                 bslrice=0;
    5845                 return bslrice;
     5844                bslcice=0;
     5845                return bslcice;
    58465846        }
    58475847
    … …  
    58525852                this->AddInput(SealevelBarystaticMaskEnum,&constant,P0Enum);
    58535853                #endif
    5854                 bslrice=0;
    5855                 return bslrice;
     5854                bslcice=0;
     5855                return bslcice;
    58565856        }
    58575857
    … …  
    59245924        _assert_(oceanarea>0.);
    59255925        if(scaleoceanarea) oceanarea=3.619e+14; // use true ocean area, m^2
    5926         bslrice = rho_ice*area*phi*I/(oceanarea*rho_water);
    5927         _assert_(!xIsNan<IssmDouble>(bslrice));
     5926        bslcice = rho_ice*area*phi*I/(oceanarea*rho_water);
     5927        _assert_(!xIsNan<IssmDouble>(bslcice));
    59285928
    59295929        if(computerigid){
    … …  
    59355935        }
    59365936
    5937         /*Plug bslrice into barystatic contribution vector:*/
     5937        /*Plug bslcice into barystatic contribution vector:*/
    59385938        if(barystatic_contribution){
    59395939                id=reCast<int>(partition[this->Sid()])+1;
    5940                 barystatic_contribution->SetValue(id,bslrice,ADD_VAL);
     5940                barystatic_contribution->SetValue(id,bslcice,ADD_VAL);
    59415941        }
    59425942        /*return :*/
    5943         return bslrice;
     5943        return bslcice;
    59445944}
    59455945/*}}}*/
    … …  
    59635963
    59645964        /*output:*/
    5965         IssmDouble bslrhydro = 0;
     5965        IssmDouble bslchydro = 0;
    59665966
    59675967        /*early return if we are on an ice cap. Nop, we may have hydro
    59685968         * and ice on the same masscon:*/
    59695969        /*if(masks->isiceonly[this->lid]){
    5970                 bslrhydro=0;
    5971                 return bslrhydro;
     5970                bslchydro=0;
     5971                return bslchydro;
    59725972        }*/
    59735973
    59745974        /*early return if we are fully floating:*/
    59755975        if (masks->isfullyfloating[this->lid]){
    5976                 bslrhydro=0;
    5977                 return bslrhydro;
     5976                bslchydro=0;
     5977                return bslchydro;
    59785978        }
    59795979
    … …  
    60006000        _assert_(oceanarea>0.);
    60016001        if(scaleoceanarea) oceanarea=3.619e+14; // use true ocean area, m^2
    6002         bslrhydro = rho_freshwater*area*phi*W/(oceanarea*rho_water);
    6003         _assert_(!xIsNan<IssmDouble>(bslrhydro));
     6002        bslchydro = rho_freshwater*area*phi*W/(oceanarea*rho_water);
     6003        _assert_(!xIsNan<IssmDouble>(bslchydro));
    60046004
    60056005        if(computeelastic){
    … …  
    60116011        }
    60126012
    6013         /*Plug bslrice into barystatic contribution vector:*/
     6013        /*Plug bslcice into barystatic contribution vector:*/
    60146014        if(barystatic_contribution){
    60156015                id=reCast<int>(partition[this->Sid()])+1;
    6016                 barystatic_contribution->SetValue(id,bslrhydro,ADD_VAL);
     6016                barystatic_contribution->SetValue(id,bslchydro,ADD_VAL);
    60176017        }
    60186018        /*output:*/
    6019         return bslrhydro;
     6019        return bslchydro;
    60206020}
    60216021/*}}}*/

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

    r25954 r25956  
    849849                case TransientSolutionEnum:{
    850850                        /*We have multiple analyses here, process one by one*/
    851                         bool isSIA,isFS,isthermal,isenthalpy,ismasstransport,isgroundingline,isstressbalance,ismovingfront,ishydrology,isdamage,issmb,isslr,isesa,isgia;
     851                        bool isSIA,isFS,isthermal,isenthalpy,ismasstransport,isgroundingline,isstressbalance,ismovingfront,ishydrology,isdamage,issmb,isslc,isesa,isgia;
    852852                        iomodel->FindConstant(&isthermal,"md.transient.isthermal");
    853853                        iomodel->FindConstant(&ismovingfront,"md.transient.ismovingfront");
    … …  
    858858                        iomodel->FindConstant(&ishydrology,"md.transient.ishydrology");
    859859                        iomodel->FindConstant(&issmb,"md.transient.issmb");
    860                         iomodel->FindConstant(&isslr,"md.transient.isslr");
     860                        iomodel->FindConstant(&isslc,"md.transient.isslc");
    861861                        iomodel->FindConstant(&isesa,"md.transient.isesa");
    862862                        iomodel->FindConstant(&isgia,"md.transient.isgia");
    … …  
    898898                                analyses_temp[numanalyses++]=DamageEvolutionAnalysisEnum;
    899899                        }
    900                         if(isslr){
     900                        if(isslc){
    901901                                analyses_temp[numanalyses++]=GiaAnalysisEnum;
    902902                                analyses_temp[numanalyses++]=SealevelchangeAnalysisEnum;
    … …  
    48134813#endif
    48144814#ifdef _HAVE_SEALEVELRISE_
    4815 void FemModel::SealevelchangeBarystatic(Vector<IssmDouble>* pRSLgi, IssmDouble* poceanarea, IssmDouble* pbslr,IssmDouble* pbslrice, IssmDouble* pbslrhydro, IssmDouble** pbslrice_partition,IssmDouble** pbslrhydro_partition,SealevelMasks* masks) { /*{{{*/
     4815void FemModel::SealevelchangeBarystatic(Vector<IssmDouble>* pRSLgi, IssmDouble* poceanarea, IssmDouble* pbslc,IssmDouble* pbslcice, IssmDouble* pbslchydro, IssmDouble** pbslcice_partition,IssmDouble** pbslchydro_partition,SealevelMasks* masks) { /*{{{*/
    48164816
    48174817        /*serialized vectors:*/
    4818         IssmDouble  bslrice       = 0.;
    4819         IssmDouble  bslrice_cpu   = 0.;
    4820         IssmDouble  bslrhydro       = 0.;
    4821         IssmDouble  bslrhydro_cpu   = 0.;
     4818        IssmDouble  bslcice       = 0.;
     4819        IssmDouble  bslcice_cpu   = 0.;
     4820        IssmDouble  bslchydro       = 0.;
     4821        IssmDouble  bslchydro_cpu   = 0.;
    48224822        IssmDouble  area      = 0.;
    48234823        IssmDouble  oceanarea      = 0.;
    … …  
    48254825        int bp_compute_fingerprints= 0;
    48264826
    4827         Vector<IssmDouble>* bslrice_partition=NULL;
    4828         IssmDouble* bslrice_partition_serial=NULL;
     4827        Vector<IssmDouble>* bslcice_partition=NULL;
     4828        IssmDouble* bslcice_partition_serial=NULL;
    48294829        IssmDouble* partitionice=NULL;
    48304830        int npartice,nel;
    48314831
    4832         Vector<IssmDouble>* bslrhydro_partition=NULL;
    4833         IssmDouble* bslrhydro_partition_serial=NULL;
     4832        Vector<IssmDouble>* bslchydro_partition=NULL;
     4833        IssmDouble* bslchydro_partition_serial=NULL;
    48344834        IssmDouble* partitionhydro=NULL;
    48354835        int nparthydro;
    … …  
    48594859        if(npartice){
    48604860                this->parameters->FindParam(&partitionice,&nel,NULL,SolidearthPartitionIceEnum);
    4861                 bslrice_partition= new Vector<IssmDouble>(npartice);
     4861                bslcice_partition= new Vector<IssmDouble>(npartice);
    48624862        }
    48634863
    … …  
    48654865        if(nparthydro){
    48664866                this->parameters->FindParam(&partitionhydro,&nel,NULL,SolidearthPartitionHydroEnum);
    4867                 bslrhydro_partition= new Vector<IssmDouble>(nparthydro);
     4867                bslchydro_partition= new Vector<IssmDouble>(nparthydro);
    48684868        }
    48694869
    48704870
    48714871        /*Call the barystatic sea level change core for ice : */
    4872         bslrice_cpu=0;
     4872        bslcice_cpu=0;
    48734873        for(Object* & object : this->elements->objects){
    48744874                Element* element = xDynamicCast<Element*>(object);
    4875                 bslrice_cpu+=element->SealevelchangeBarystaticIce(RSLgi,masks, bslrice_partition,partitionice,oceanarea);
     4875                bslcice_cpu+=element->SealevelchangeBarystaticIce(RSLgi,masks, bslcice_partition,partitionice,oceanarea);
    48764876        }
    48774877
    48784878        /*Call the barystatic sea level change core for hydro: */
    4879         bslrhydro_cpu=0;
     4879        bslchydro_cpu=0;
    48804880        for(int i=0;i<elements->Size();i++){
    48814881                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    4882                 bslrhydro_cpu+=element->SealevelchangeBarystaticHydro(RSLgi,masks, bslrhydro_partition,partitionhydro,oceanarea);
     4882                bslchydro_cpu+=element->SealevelchangeBarystaticHydro(RSLgi,masks, bslchydro_partition,partitionhydro,oceanarea);
    48834883        }
    48844884
    … …  
    48974897
    48984898        /*Sum all barystatic components from all cpus:*/
    4899         ISSM_MPI_Reduce (&bslrice_cpu,&bslrice,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
    4900         ISSM_MPI_Bcast(&bslrice,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
    4901         _assert_(!xIsNan<IssmDouble>(bslrice));
    4902 
    4903         ISSM_MPI_Reduce (&bslrhydro_cpu,&bslrhydro,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
    4904         ISSM_MPI_Bcast(&bslrhydro,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
    4905         _assert_(!xIsNan<IssmDouble>(bslrhydro));
     4899        ISSM_MPI_Reduce (&bslcice_cpu,&bslcice,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
     4900        ISSM_MPI_Bcast(&bslcice,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
     4901        _assert_(!xIsNan<IssmDouble>(bslcice));
     4902
     4903        ISSM_MPI_Reduce (&bslchydro_cpu,&bslchydro,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
     4904        ISSM_MPI_Bcast(&bslchydro,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
     4905        _assert_(!xIsNan<IssmDouble>(bslchydro));
    49064906
    49074907        /*Take care of partition vectors:*/
    4908         if(bslrice_partition){
    4909                 bslrice_partition->Assemble();
    4910                 bslrice_partition_serial=bslrice_partition->ToMPISerial();
    4911         }
    4912         if(bslrhydro_partition){
    4913                 bslrhydro_partition->Assemble();
    4914                 bslrhydro_partition_serial=bslrhydro_partition->ToMPISerial();
     4908        if(bslcice_partition){
     4909                bslcice_partition->Assemble();
     4910                bslcice_partition_serial=bslcice_partition->ToMPISerial();
     4911        }
     4912        if(bslchydro_partition){
     4913                bslchydro_partition->Assemble();
     4914                bslchydro_partition_serial=bslchydro_partition->ToMPISerial();
    49154915        }
    49164916
    … …  
    49194919        xDelete<int>(indices);
    49204920        xDelete<IssmDouble>(RSLgi);
    4921         if(bslrhydro_partition)delete bslrhydro_partition;
    4922         if(bslrice_partition)delete bslrice_partition;
     4921        if(bslchydro_partition)delete bslchydro_partition;
     4922        if(bslcice_partition)delete bslcice_partition;
    49234923        if(partitionhydro)xDelete<IssmDouble>(partitionhydro);
    49244924        if(partitionice)xDelete<IssmDouble>(partitionice);
    … …  
    49264926        /*Assign output pointers:*/
    49274927        *poceanarea = oceanarea;
    4928         *pbslrice  = bslrice;
    4929         *pbslrhydro  = bslrhydro;
    4930         *pbslr=bslrhydro+bslrice;
    4931         *pbslrice_partition=bslrice_partition_serial;
    4932         *pbslrhydro_partition=bslrhydro_partition_serial;
     4928        *pbslcice  = bslcice;
     4929        *pbslchydro  = bslchydro;
     4930        *pbslc=bslchydro+bslcice;
     4931        *pbslcice_partition=bslcice_partition_serial;
     4932        *pbslchydro_partition=bslchydro_partition_serial;
    49334933
    49344934}

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

    r25954 r25956  
    167167                #endif
    168168                #ifdef _HAVE_SEALEVELRISE_
    169                 void SealevelchangeBarystatic(Vector<IssmDouble>* pRSLgi, IssmDouble* poceanarea, IssmDouble* pbslr,IssmDouble* pbslrice, IssmDouble* pbslrhydro, IssmDouble** pbslrice_partition,IssmDouble** pbslrhydro_partition, SealevelMasks* masks);
     169                void SealevelchangeBarystatic(Vector<IssmDouble>* pRSLgi, IssmDouble* poceanarea, IssmDouble* pbslc,IssmDouble* pbslcice, IssmDouble* pbslchydro, IssmDouble** pbslcice_partition,IssmDouble** pbslchydro_partition, SealevelMasks* masks);
    170170                void SealevelchangeSal(Vector<IssmDouble>* pSgo, Vector<IssmDouble>* pSg_old,  SealevelMasks* masks,bool verboseconvolution);
    171171                void SealevelchangeRotationalFeedback(Vector<IssmDouble>* pRSLgo_rot, Vector<IssmDouble>* pRSLg_old, IssmDouble* pIxz, IssmDouble* pIyz, IssmDouble* pIzz, SealevelMasks* masks);

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

    r25947 r25956  
    8181void TransferSealevel(FemModel* femmodel,int forcingenum);
    8282void EarthMassTransport(FemModel* femmodel);
    83 void slrconvergence(bool* pconverged, Vector<IssmDouble>* RSLg,Vector<IssmDouble>* RSLg_old,IssmDouble eps_rel,IssmDouble eps_abs);
     83void slcconvergence(bool* pconverged, Vector<IssmDouble>* RSLg,Vector<IssmDouble>* RSLg_old,IssmDouble eps_rel,IssmDouble eps_abs);
    8484
    8585//solution configuration

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

    r25954 r25956  
    2222        /*Parameters, variables:*/
    2323        bool save_results;
    24         bool isslr=0;
     24        bool isslc=0;
    2525        bool isgia=0;
    2626        int  grd=0;
    … …  
    3030
    3131        /*Retrieve parameters:*/
    32         femmodel->parameters->FindParam(&isslr,TransientIsslrEnum);
     32        femmodel->parameters->FindParam(&isslc,TransientIsslcEnum);
    3333        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    3434        femmodel->parameters->FindParam(&save_results,SaveResultsEnum);
    … …  
    3939        /*in case we are running SealevelchangeSolutionEnum, then bypass transient settings:*/
    4040        if(solution_type==SealevelchangeSolutionEnum){
    41                 isslr=1;
     41                isslc=1;
    4242                isgia=1;
    4343        }
    4444
    4545        /*Should we be here?:*/
    46         if(!isslr)return;
     46        if(!isslc)return;
    4747
    4848        /*Verbose: */
    … …  
    115115   
    116116        /*parameters: */
    117         bool isslr=0;
     117        bool isslc=0;
    118118        int  solution_type;
    119119        IssmDouble          dt;
    120120
    121121        /*Retrieve parameters:*/
    122         femmodel->parameters->FindParam(&isslr,TransientIsslrEnum);
     122        femmodel->parameters->FindParam(&isslc,TransientIsslcEnum);
    123123        femmodel->parameters->FindParam(&horiz,SolidearthSettingsHorizEnum);
    124124        femmodel->parameters->FindParam(&dt,TimesteppingTimeStepEnum);
    … …  
    126126
    127127        /*in case we are running SealevelchangeSolutionEnum, then bypass transient settings:*/
    128         if(solution_type==SealevelchangeSolutionEnum)isslr=1;
     128        if(solution_type==SealevelchangeSolutionEnum)isslc=1;
    129129
    130130        /*Should we be here?:*/
    131         if(!isslr)return;
     131        if(!isslc)return;
    132132
    133133        /*Verbose: */
    … …  
    331331
    332332        /*parameters: */
    333         bool isslr=0;
     333        bool isslc=0;
    334334        int  solution_type;
    335335        IssmDouble          dt;
    … …  
    337337        IssmDouble time;
    338338
    339         IssmDouble cumgmtslr=0;
    340         IssmDouble cumbslr=0;
    341         IssmDouble cumgmslr=0;
    342         IssmDouble gmtslr=0;
     339        IssmDouble cumgmtslc=0;
     340        IssmDouble cumbslc=0;
     341        IssmDouble cumgmslc=0;
     342        IssmDouble gmtslc=0;
    343343
    344344        /*Retrieve parameters:*/
    345345        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    346         femmodel->parameters->FindParam(&isslr,TransientIsslrEnum);
     346        femmodel->parameters->FindParam(&isslc,TransientIsslcEnum);
    347347       
    348348        /*in case we are running SealevelchangeSolutionEnum, then bypass transient settings:*/
    349         if(solution_type==SealevelchangeSolutionEnum)isslr=1;
     349        if(solution_type==SealevelchangeSolutionEnum)isslc=1;
    350350
    351351        /*Should we be here?:*/
    352         if(!isslr)return;
     352        if(!isslc)return;
    353353
    354354        /*Verbose: */
    … …  
    366366
    367367        /*cumulate thermal steric rate:*/
    368         femmodel->parameters->FindParam(&cumgmtslr,CumGmtslrEnum);
    369         femmodel->parameters->FindParam(&cumbslr,CumBslrEnum);
    370 
    371         gmtslr=steric_rate_g->Max()*dt;
    372         cumgmtslr+=gmtslr;
    373         cumgmslr=cumbslr+cumgmtslr;
    374 
    375         femmodel->parameters->SetParam(cumgmtslr,CumGmtslrEnum);
    376         femmodel->parameters->SetParam(cumgmslr,CumGmslrEnum);
     368        femmodel->parameters->FindParam(&cumgmtslc,CumGmtslcEnum);
     369        femmodel->parameters->FindParam(&cumbslc,CumBslcEnum);
     370
     371        gmtslc=steric_rate_g->Max()*dt;
     372        cumgmtslc+=gmtslc;
     373        cumgmslc=cumbslc+cumgmtslc;
     374
     375        femmodel->parameters->SetParam(cumgmtslc,CumGmtslcEnum);
     376        femmodel->parameters->SetParam(cumgmslc,CumGmslcEnum);
    377377       
    378378        /*Outputs some metrics:*/
    … …  
    380380        femmodel->parameters->FindParam(&time,TimeEnum);
    381381
    382         femmodel->results->AddResult(new GenericExternalResult<IssmDouble>(femmodel->results->Size()+1,GmtslrEnum,gmtslr,step,time));
    383         femmodel->results->AddResult(new GenericExternalResult<IssmDouble>(femmodel->results->Size()+1,CumGmtslrEnum,cumgmtslr,step,time));
    384         femmodel->results->AddResult(new GenericExternalResult<IssmDouble>(femmodel->results->Size()+1,CumGmslrEnum,cumgmslr,step,time));
     382        femmodel->results->AddResult(new GenericExternalResult<IssmDouble>(femmodel->results->Size()+1,GmtslcEnum,gmtslc,step,time));
     383        femmodel->results->AddResult(new GenericExternalResult<IssmDouble>(femmodel->results->Size()+1,CumGmtslcEnum,cumgmtslc,step,time));
     384        femmodel->results->AddResult(new GenericExternalResult<IssmDouble>(femmodel->results->Size()+1,CumGmslcEnum,cumgmslc,step,time));
    385385
    386386        /*update element inputs:*/
    … …  
    480480
    481481        /*barystatic contribution:*/
    482         IssmDouble bslr;
    483         IssmDouble bslrice;
    484         IssmDouble* bslrice_partition=NULL;
    485         IssmDouble bslrhydro;
    486         IssmDouble* bslrhydro_partition=NULL;
    487         IssmDouble cumbslr;
    488         IssmDouble cumbslrice;
    489         IssmDouble cumbslrhydro;
    490         IssmDouble* cumbslrice_partition=NULL;
     482        IssmDouble bslc;
     483        IssmDouble bslcice;
     484        IssmDouble* bslcice_partition=NULL;
     485        IssmDouble bslchydro;
     486        IssmDouble* bslchydro_partition=NULL;
     487        IssmDouble cumbslc;
     488        IssmDouble cumbslcice;
     489        IssmDouble cumbslchydro;
     490        IssmDouble* cumbslcice_partition=NULL;
    491491        int npartice;
    492         IssmDouble* cumbslrhydro_partition=NULL;
     492        IssmDouble* cumbslchydro_partition=NULL;
    493493        int nparthydro;
    494494       
    495         if(VerboseSolution()) _printf0_("         computing bslr components on ice\n");
     495        if(VerboseSolution()) _printf0_("         computing bslc components on ice\n");
    496496
    497497        /*Figure out size of g-set deflection vector and allocate solution vector: */
    … …  
    501501        femmodel->parameters->FindParam(&step,StepEnum);
    502502        femmodel->parameters->FindParam(&time,TimeEnum);
    503         femmodel->parameters->FindParam(&cumbslr,CumBslrEnum);
    504         femmodel->parameters->FindParam(&cumbslrice,CumBslrIceEnum);
    505         femmodel->parameters->FindParam(&cumbslrhydro,CumBslrHydroEnum);
     503        femmodel->parameters->FindParam(&cumbslc,CumBslcEnum);
     504        femmodel->parameters->FindParam(&cumbslcice,CumBslcIceEnum);
     505        femmodel->parameters->FindParam(&cumbslchydro,CumBslcHydroEnum);
    506506        femmodel->parameters->FindParam(&npartice,SolidearthNpartIceEnum);
    507507        femmodel->parameters->FindParam(&nparthydro,SolidearthNpartHydroEnum);
    508         if(npartice) femmodel->parameters->FindParam(&cumbslrice_partition,&npartice,NULL,CumBslrIcePartitionEnum);
    509         if(nparthydro) femmodel->parameters->FindParam(&cumbslrhydro_partition,&nparthydro,NULL,CumBslrHydroPartitionEnum);
     508        if(npartice) femmodel->parameters->FindParam(&cumbslcice_partition,&npartice,NULL,CumBslcIcePartitionEnum);
     509        if(nparthydro) femmodel->parameters->FindParam(&cumbslchydro_partition,&nparthydro,NULL,CumBslcHydroPartitionEnum);
    510510
    511511        /*Initialize:*/
    512512        RSLgi = new Vector<IssmDouble>(gsize);
    513513
    514         /*call the bslr main module: */
    515         femmodel->SealevelchangeBarystatic(RSLgi,&oceanarea,&bslr, &bslrice, &bslrhydro, &bslrice_partition, &bslrhydro_partition,masks); //this computes
     514        /*call the bslc main module: */
     515        femmodel->SealevelchangeBarystatic(RSLgi,&oceanarea,&bslc, &bslcice, &bslchydro, &bslcice_partition, &bslchydro_partition,masks); //this computes
    516516
    517517        /*we need to average RSLgi over the ocean: RHS term  4 in Eq.4 of Farrel and clarke. Only the elements can do that: */
    518518        RSLgi_oceanaverage=femmodel->SealevelchangeOceanAverage(RSLgi,masks, oceanarea);
    519519
    520         /*RSLg is the sum of the pure bslr component (term 3) and the contribution from the perturbation to the graviation potential due to the
     520        /*RSLg is the sum of the pure bslc component (term 3) and the contribution from the perturbation to the graviation potential due to the
    521521         * presence of ice (terms 1 and 4 in Eq.4 of Farrel and Clarke):*/
    522         RSLgi->Shift(-bslr-RSLgi_oceanaverage);
    523 
    524         /*save bslr and cumulated bslr value for results:{{{ */
    525         femmodel->results->AddResult(new GenericExternalResult<IssmDouble>(femmodel->results->Size()+1,BslrEnum,-bslr,step,time));
    526         femmodel->results->AddResult(new GenericExternalResult<IssmDouble>(femmodel->results->Size()+1,BslrIceEnum,-bslrice,step,time));
    527         femmodel->results->AddResult(new GenericExternalResult<IssmDouble>(femmodel->results->Size()+1,BslrHydroEnum,-bslrhydro,step,time));
     522        RSLgi->Shift(-bslc-RSLgi_oceanaverage);
     523
     524        /*save bslc and cumulated bslc value for results:{{{ */
     525        femmodel->results->AddResult(new GenericExternalResult<IssmDouble>(femmodel->results->Size()+1,BslcEnum,-bslc,step,time));
     526        femmodel->results->AddResult(new GenericExternalResult<IssmDouble>(femmodel->results->Size()+1,BslcIceEnum,-bslcice,step,time));
     527        femmodel->results->AddResult(new GenericExternalResult<IssmDouble>(femmodel->results->Size()+1,BslcHydroEnum,-bslchydro,step,time));
    528528
    529529        //cumulative barystatic contribution:
    530         cumbslr=cumbslr-bslr;
    531         cumbslrice=cumbslrice-bslrice;
    532         cumbslrhydro=cumbslrhydro-bslrhydro;
    533 
    534         femmodel->parameters->SetParam(cumbslr,CumBslrEnum);
    535         femmodel->parameters->SetParam(cumbslrice,CumBslrIceEnum);
    536         femmodel->parameters->SetParam(cumbslrhydro,CumBslrHydroEnum);
    537 
    538         femmodel->results->AddResult(new GenericExternalResult<IssmDouble>(femmodel->results->Size()+1,CumBslrEnum,cumbslr,step,time));
    539         femmodel->results->AddResult(new GenericExternalResult<IssmDouble>(femmodel->results->Size()+1,CumBslrIceEnum,cumbslrice,step,time));
    540         femmodel->results->AddResult(new GenericExternalResult<IssmDouble>(femmodel->results->Size()+1,CumBslrHydroEnum,cumbslrhydro,step,time));
     530        cumbslc=cumbslc-bslc;
     531        cumbslcice=cumbslcice-bslcice;
     532        cumbslchydro=cumbslchydro-bslchydro;
     533
     534        femmodel->parameters->SetParam(cumbslc,CumBslcEnum);
     535        femmodel->parameters->SetParam(cumbslcice,CumBslcIceEnum);
     536        femmodel->parameters->SetParam(cumbslchydro,CumBslcHydroEnum);
     537
     538        femmodel->results->AddResult(new GenericExternalResult<IssmDouble>(femmodel->results->Size()+1,CumBslcEnum,cumbslc,step,time));
     539        femmodel->results->AddResult(new GenericExternalResult<IssmDouble>(femmodel->results->Size()+1,CumBslcIceEnum,cumbslcice,step,time));
     540        femmodel->results->AddResult(new GenericExternalResult<IssmDouble>(femmodel->results->Size()+1,CumBslcHydroEnum,cumbslchydro,step,time));
    541541
    542542        //cumulative barystatic contributions by partition:
    543543        if(npartice){
    544                 for(int i=0;i<npartice;i++) cumbslrice_partition[i] -= bslrice_partition[i];
    545                 femmodel->parameters->SetParam(cumbslrice_partition,npartice,1,CumBslrIcePartitionEnum);
    546                 femmodel->results->AddResult(new GenericExternalResult<IssmDouble*>(femmodel->results->Size()+1,CumBslrIcePartitionEnum,cumbslrice_partition,npartice,1,step,time));
     544                for(int i=0;i<npartice;i++) cumbslcice_partition[i] -= bslcice_partition[i];
     545                femmodel->parameters->SetParam(cumbslcice_partition,npartice,1,CumBslcIcePartitionEnum);
     546                femmodel->results->AddResult(new GenericExternalResult<IssmDouble*>(femmodel->results->Size()+1,CumBslcIcePartitionEnum,cumbslcice_partition,npartice,1,step,time));
    547547        }
    548548
    549549        if(nparthydro){
    550                 for(int i=0;i<nparthydro;i++) cumbslrhydro_partition[i] -= bslrhydro_partition[i];
    551                 femmodel->parameters->SetParam(cumbslrhydro_partition,nparthydro,1,CumBslrHydroPartitionEnum);
    552                 femmodel->results->AddResult(new GenericExternalResult<IssmDouble*>(femmodel->results->Size()+1,CumBslrHydroPartitionEnum,cumbslrhydro_partition,nparthydro,1,step,time));
     550                for(int i=0;i<nparthydro;i++) cumbslchydro_partition[i] -= bslchydro_partition[i];
     551                femmodel->parameters->SetParam(cumbslchydro_partition,nparthydro,1,CumBslcHydroPartitionEnum);
     552                femmodel->results->AddResult(new GenericExternalResult<IssmDouble*>(femmodel->results->Size()+1,CumBslcHydroPartitionEnum,cumbslchydro_partition,nparthydro,1,step,time));
    553553        }
    554554        /*}}}*/
    … …  
    645645
    646646                /*convergence criterion:*/
    647                 slrconvergence(&converged,RSLg,RSLg_old,eps_rel,eps_abs);
     647                slcconvergence(&converged,RSLg,RSLg_old,eps_rel,eps_abs);
    648648               
    649649       
    … …  
    11041104
    11051105        /*This mass transport module for the Earth is because we might have thickness variations as spcs
    1106          * specified in the md.slr class, outside of what we will get from the icecaps. That's why we get t
     1106         * specified in the md.solidearth class, outside of what we will get from the icecaps. That's why we get t
    11071107         * the thickness variations from SealevelchangeSpcthicknessEnum.*/
    11081108
    … …  
    11351135
    11361136} /*}}}*/
    1137 void slrconvergence(bool* pconverged, Vector<IssmDouble>* RSLg,Vector<IssmDouble>* RSLg_old,IssmDouble eps_rel,IssmDouble eps_abs){ /*{{{*/
     1137void slcconvergence(bool* pconverged, Vector<IssmDouble>* RSLg,Vector<IssmDouble>* RSLg_old,IssmDouble eps_rel,IssmDouble eps_abs){ /*{{{*/
    11381138
    11391139        bool converged=true;

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

    r25947 r25956  
    2424        /*parameters: */
    2525        IssmDouble finaltime,dt,yts;
    26         bool       isoceancoupling,iscontrol,isautodiff,isslr;
     26        bool       isoceancoupling,iscontrol,isautodiff,isslc;
    2727        int        timestepping;
    2828        int        output_frequency,checkpoint_frequency;
    … …  
    4545        femmodel->parameters->FindParam(&output_frequency,SettingsOutputFrequencyEnum);
    4646        femmodel->parameters->FindParam(&timestepping,TimesteppingTypeEnum);
    47         femmodel->parameters->FindParam(&isslr,TransientIsslrEnum);
     47        femmodel->parameters->FindParam(&isslc,TransientIsslcEnum);
    4848        femmodel->parameters->FindParam(&isoceancoupling,TransientIsoceancouplingEnum);
    4949        femmodel->parameters->FindParam(&amr_frequency,TransientAmrFrequencyEnum);
    … …  
    6262        #endif
    6363
    64         if(isslr) sealevelchange_geometry(femmodel);
     64        if(isslc) sealevelchange_geometry(femmodel);
    6565
    6666        while(time < finaltime - (yts*DBL_EPSILON)){ //make sure we run up to finaltime.
    … …  
    139139        /*parameters: */
    140140        bool isstressbalance,ismasstransport,issmb,isthermal,isgroundingline,isgia,isesa;
    141         bool isslr,ismovingfront,isdamageevolution,ishydrology,isoceancoupling,save_results;
     141        bool isslc,ismovingfront,isdamageevolution,ishydrology,isoceancoupling,save_results;
    142142        int  step,sb_coupling_frequency;
    143143        int  domaintype,numoutputs;
    … …  
    154154        femmodel->parameters->FindParam(&isgia,TransientIsgiaEnum);
    155155        femmodel->parameters->FindParam(&isesa,TransientIsesaEnum);
    156         femmodel->parameters->FindParam(&isslr,TransientIsslrEnum);
     156        femmodel->parameters->FindParam(&isslc,TransientIsslcEnum);
    157157        femmodel->parameters->FindParam(&isgroundingline,TransientIsgroundinglineEnum);
    158158        femmodel->parameters->FindParam(&ismovingfront,TransientIsmovingfrontEnum);
    … …  
    236236
    237237        /*Sea level change: */
    238         if(isslr){
     238        if(isslc){
    239239                if(VerboseSolution()) _printf0_("   computing sea level change\n");
    240240                sealevelchange_core(femmodel);
    … …  
    260260        IssmDouble output_value;
    261261        IssmDouble finaltime,dt,yts,time;
    262         bool       isoceancoupling,isslr;
     262        bool       isoceancoupling,isslc;
    263263        int        step,timestepping;
    264264        int        checkpoint_frequency;
    … …  
    273273        femmodel->parameters->FindParam(&yts,ConstantsYtsEnum);
    274274        femmodel->parameters->FindParam(&timestepping,TimesteppingTypeEnum);
    275         femmodel->parameters->FindParam(&isslr,TransientIsslrEnum);
     275        femmodel->parameters->FindParam(&isslc,TransientIsslcEnum);
    276276        femmodel->parameters->FindParam(&checkpoint_frequency,SettingsCheckpointFrequencyEnum); _assert_(checkpoint_frequency>0);
    277         if(isslr) sealevelchange_geometry(femmodel);
     277        if(isslc) sealevelchange_geometry(femmodel);
    278278
    279279        std::vector<IssmDouble> time_all;

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

    r25947 r25956  
    8282                parameters->AddObject(iomodel->CopyConstantObject("md.transient.ishydrology",TransientIshydrologyEnum));
    8383                parameters->AddObject(iomodel->CopyConstantObject("md.transient.ismovingfront",TransientIsmovingfrontEnum));
    84                 parameters->AddObject(iomodel->CopyConstantObject("md.transient.isslr",TransientIsslrEnum));
     84                parameters->AddObject(iomodel->CopyConstantObject("md.transient.isslc",TransientIsslcEnum));
    8585                parameters->AddObject(iomodel->CopyConstantObject("md.transient.iscoupler",TransientIscouplerEnum));
    8686                parameters->AddObject(iomodel->CopyConstantObject("md.transient.isoceancoupling",TransientIsoceancouplingEnum));
    … …  
    356356                                                parameters->AddObject(iomodel->CopyConstantObject("md.materials.rheology_law",MaterialsRheologyLawEnum));
    357357
    358                                                 /*slr:*/
     358                                                /*slc:*/
    359359                                                parameters->AddObject(iomodel->CopyConstantObject("md.materials.earth_density",MaterialsEarthDensityEnum));
    360360                                                break;

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

    r25947 r25956  
    110110syn keyword cConstant ControlInputSizeNEnum
    111111syn keyword cConstant ControlInputInterpolationEnum
    112 syn keyword cConstant CumBslrEnum
    113 syn keyword cConstant CumBslrIceEnum
    114 syn keyword cConstant CumBslrHydroEnum
    115 syn keyword cConstant CumBslrIcePartitionEnum
    116 syn keyword cConstant CumBslrHydroPartitionEnum
    117 syn keyword cConstant CumGmtslrEnum
    118 syn keyword cConstant CumGmslrEnum
     112syn keyword cConstant CumBslcEnum
     113syn keyword cConstant CumBslcIceEnum
     114syn keyword cConstant CumBslcHydroEnum
     115syn keyword cConstant CumBslcIcePartitionEnum
     116syn keyword cConstant CumBslcHydroPartitionEnum
     117syn keyword cConstant CumGmtslcEnum
     118syn keyword cConstant CumGmslcEnum
    119119syn keyword cConstant DamageC1Enum
    120120syn keyword cConstant DamageC2Enum
    … …  
    488488syn keyword cConstant TransientIsmovingfrontEnum
    489489syn keyword cConstant TransientIsoceancouplingEnum
    490 syn keyword cConstant TransientIsslrEnum
     490syn keyword cConstant TransientIsslcEnum
    491491syn keyword cConstant TransientIssmbEnum
    492492syn keyword cConstant TransientIsstressbalanceEnum
    … …  
    721721syn keyword cConstant SealevelNEsaRateEnum
    722722syn keyword cConstant SealevelRSLEnum
    723 syn keyword cConstant BslrEnum
    724 syn keyword cConstant BslrIceEnum
    725 syn keyword cConstant BslrHydroEnum
    726 syn keyword cConstant BslrRateEnum
    727 syn keyword cConstant GmtslrEnum
     723syn keyword cConstant BslcEnum
     724syn keyword cConstant BslcIceEnum
     725syn keyword cConstant BslcHydroEnum
     726syn keyword cConstant BslcRateEnum
     727syn keyword cConstant GmtslcEnum
    728728syn keyword cConstant SealevelRSLBarystaticEnum
    729729syn keyword cConstant SealevelRSLRateEnum

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

    r25947 r25956  
    104104        ControlInputSizeNEnum,
    105105        ControlInputInterpolationEnum,
    106         CumBslrEnum,
    107         CumBslrIceEnum,
    108         CumBslrHydroEnum,
    109         CumBslrIcePartitionEnum,
    110         CumBslrHydroPartitionEnum,
    111         CumGmtslrEnum,
    112         CumGmslrEnum,
     106        CumBslcEnum,
     107        CumBslcIceEnum,
     108        CumBslcHydroEnum,
     109        CumBslcIcePartitionEnum,
     110        CumBslcHydroPartitionEnum,
     111        CumGmtslcEnum,
     112        CumGmslcEnum,
    113113        DamageC1Enum,
    114114        DamageC2Enum,
    … …  
    482482        TransientIsmovingfrontEnum,
    483483        TransientIsoceancouplingEnum,
    484         TransientIsslrEnum,
     484        TransientIsslcEnum,
    485485        TransientIssmbEnum,
    486486        TransientIsstressbalanceEnum,
    … …  
    717717        SealevelNEsaRateEnum,
    718718        SealevelRSLEnum,
    719         BslrEnum,
    720         BslrIceEnum,
    721         BslrHydroEnum,
    722         BslrRateEnum,
    723         GmtslrEnum,
     719        BslcEnum,
     720        BslcIceEnum,
     721        BslcHydroEnum,
     722        BslcRateEnum,
     723        GmtslcEnum,
    724724        SealevelRSLBarystaticEnum,
    725725        SealevelRSLRateEnum,

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

    r25947 r25956  
    112112                case ControlInputSizeNEnum : return "ControlInputSizeN";
    113113                case ControlInputInterpolationEnum : return "ControlInputInterpolation";
    114                 case CumBslrEnum : return "CumBslr";
    115                 case CumBslrIceEnum : return "CumBslrIce";
    116                 case CumBslrHydroEnum : return "CumBslrHydro";
    117                 case CumBslrIcePartitionEnum : return "CumBslrIcePartition";
    118                 case CumBslrHydroPartitionEnum : return "CumBslrHydroPartition";
    119                 case CumGmtslrEnum : return "CumGmtslr";
    120                 case CumGmslrEnum : return "CumGmslr";
     114                case CumBslcEnum : return "CumBslc";
     115                case CumBslcIceEnum : return "CumBslcIce";
     116                case CumBslcHydroEnum : return "CumBslcHydro";
     117                case CumBslcIcePartitionEnum : return "CumBslcIcePartition";
     118                case CumBslcHydroPartitionEnum : return "CumBslcHydroPartition";
     119                case CumGmtslcEnum : return "CumGmtslc";
     120                case CumGmslcEnum : return "CumGmslc";
    121121                case DamageC1Enum : return "DamageC1";
    122122                case DamageC2Enum : return "DamageC2";
    … …  
    490490                case TransientIsmovingfrontEnum : return "TransientIsmovingfront";
    491491                case TransientIsoceancouplingEnum : return "TransientIsoceancoupling";
    492                 case TransientIsslrEnum : return "TransientIsslr";
     492                case TransientIsslcEnum : return "TransientIsslc";
    493493                case TransientIssmbEnum : return "TransientIssmb";
    494494                case TransientIsstressbalanceEnum : return "TransientIsstressbalance";
    … …  
    723723                case SealevelNEsaRateEnum : return "SealevelNEsaRate";
    724724                case SealevelRSLEnum : return "SealevelRSL";
    725                 case BslrEnum : return "Bslr";
    726                 case BslrIceEnum : return "BslrIce";
    727                 case BslrHydroEnum : return "BslrHydro";
    728                 case BslrRateEnum : return "BslrRate";
    729                 case GmtslrEnum : return "Gmtslr";
     725                case BslcEnum : return "Bslc";
     726                case BslcIceEnum : return "BslcIce";
     727                case BslcHydroEnum : return "BslcHydro";
     728                case BslcRateEnum : return "BslcRate";
     729                case GmtslcEnum : return "Gmtslc";
    730730                case SealevelRSLBarystaticEnum : return "SealevelRSLBarystatic";
    731731                case SealevelRSLRateEnum : return "SealevelRSLRate";

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

    r25947 r25956  
    112112              else if (strcmp(name,"ControlInputSizeN")==0) return ControlInputSizeNEnum;
    113113              else if (strcmp(name,"ControlInputInterpolation")==0) return ControlInputInterpolationEnum;
    114               else if (strcmp(name,"CumBslr")==0) return CumBslrEnum;
    115               else if (strcmp(name,"CumBslrIce")==0) return CumBslrIceEnum;
    116               else if (strcmp(name,"CumBslrHydro")==0) return CumBslrHydroEnum;
    117               else if (strcmp(name,"CumBslrIcePartition")==0) return CumBslrIcePartitionEnum;
    118               else if (strcmp(name,"CumBslrHydroPartition")==0) return CumBslrHydroPartitionEnum;
    119               else if (strcmp(name,"CumGmtslr")==0) return CumGmtslrEnum;
    120               else if (strcmp(name,"CumGmslr")==0) return CumGmslrEnum;
     114              else if (strcmp(name,"CumBslc")==0) return CumBslcEnum;
     115              else if (strcmp(name,"CumBslcIce")==0) return CumBslcIceEnum;
     116              else if (strcmp(name,"CumBslcHydro")==0) return CumBslcHydroEnum;
     117              else if (strcmp(name,"CumBslcIcePartition")==0) return CumBslcIcePartitionEnum;
     118              else if (strcmp(name,"CumBslcHydroPartition")==0) return CumBslcHydroPartitionEnum;
     119              else if (strcmp(name,"CumGmtslc")==0) return CumGmtslcEnum;
     120              else if (strcmp(name,"CumGmslc")==0) return CumGmslcEnum;
    121121              else if (strcmp(name,"DamageC1")==0) return DamageC1Enum;
    122122              else if (strcmp(name,"DamageC2")==0) return DamageC2Enum;
    … …  
    499499              else if (strcmp(name,"TransientIsmovingfront")==0) return TransientIsmovingfrontEnum;
    500500              else if (strcmp(name,"TransientIsoceancoupling")==0) return TransientIsoceancouplingEnum;
    501               else if (strcmp(name,"TransientIsslr")==0) return TransientIsslrEnum;
     501              else if (strcmp(name,"TransientIsslc")==0) return TransientIsslcEnum;
    502502              else if (strcmp(name,"TransientIssmb")==0) return TransientIssmbEnum;
    503503              else if (strcmp(name,"TransientIsstressbalance")==0) return TransientIsstressbalanceEnum;
    … …  
    738738              else if (strcmp(name,"SealevelNEsaRate")==0) return SealevelNEsaRateEnum;
    739739              else if (strcmp(name,"SealevelRSL")==0) return SealevelRSLEnum;
    740               else if (strcmp(name,"Bslr")==0) return BslrEnum;
    741               else if (strcmp(name,"BslrIce")==0) return BslrIceEnum;
    742               else if (strcmp(name,"BslrHydro")==0) return BslrHydroEnum;
    743               else if (strcmp(name,"BslrRate")==0) return BslrRateEnum;
    744               else if (strcmp(name,"Gmtslr")==0) return GmtslrEnum;
     740              else if (strcmp(name,"Bslc")==0) return BslcEnum;
     741              else if (strcmp(name,"BslcIce")==0) return BslcIceEnum;
     742              else if (strcmp(name,"BslcHydro")==0) return BslcHydroEnum;
     743              else if (strcmp(name,"BslcRate")==0) return BslcRateEnum;
     744              else if (strcmp(name,"Gmtslc")==0) return GmtslcEnum;
    745745              else if (strcmp(name,"SealevelRSLBarystatic")==0) return SealevelRSLBarystaticEnum;
    746746              else if (strcmp(name,"SealevelRSLRate")==0) return SealevelRSLRateEnum;

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

    r25947 r25956  
    2121                function md = checkconsistency(self,md,solution,analyses) % {{{
    2222
    23                         if ~ismember('SealevelriseAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.solidearth.settings.isgrd==0),
     23                        if ~ismember('SealevelchangeAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.solidearth.settings.isgrd==0),
    2424                                error('additionalsolidearthsolution checkconsistency error message: need to run GRD solution if you are supplying a GRD additional pattern solution');
    2525                        end

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

    r25684 r25956  
    165165
    166166                        %what is the executable being called?
    167                         executable='issm_slr.exe';
     167                        executable='issm_slc.exe';
    168168
    169169                        if ispc(), error('BuildQueueScriptMultipleModels not support yet on windows machines');end;

  • issm/trunk-jpl/src/m/classes/clusters/localpfe.m

    r22664 r25956  
    104104
    105105                        %what is the executable being called?
    106                         executable='issm_slr.exe';
     106                        executable='issm_slc.exe';
    107107
    108108                        if ispc(), error('BuildQueueScriptMultipleModels not support yet on windows machines');end;

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

    r25594 r25956  
    214214
    215215                        %what is the executable being called?
    216                         executable='issm_slr.exe';
     216                        executable='issm_slc.exe';
    217217
    218218                        if ispc(), error('BuildQueueScriptMultipleModels not support yet on windows machines');end;

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

    r25055 r25956  
    3939
    4040                        %Early return
    41                         if ~ismember('SealevelriseAnalysis',analyses), return; end
    42                         if (strcmp(solution,'TransientSolution') & md.transient.isslr == 0), return; end
     41                        if ~ismember('SealevelchangeAnalysis',analyses), return; end
     42                        if (strcmp(solution,'TransientSolution') & md.transient.isslc == 0), return; end
    4343                        md = checkfield(md,'fieldname','dsl.global_average_thermosteric_sea_level_change','NaN',1,'Inf',1);
    4444                        md = checkfield(md,'fieldname','dsl.sea_surface_height_change_above_geoid','NaN',1,'Inf',1,'timeseries',1);
    … …  
    4646                        md = checkfield(md,'fieldname','dsl.compute_fingerprints','NaN',1,'Inf',1,'values',[0,1]);
    4747                        if self.compute_fingerprints,
    48                                 %check geodetic flag of slr is on:
    49                                 if md.slr.geodetic==0,
    50                                         error('DSL checkconsistency error message: if bottom pressure fingerprints computations are requested, slr class should have geodetic flag on');
     48                                %check geodetic flag of is on:
     49                                if md.solidearth.settings.isgrd==0,
     50                                        error('DSL checkconsistency error message: if bottom pressure fingerprints computations are requested, solidearth class should have grd flag on');
    5151                                end
    5252                        end

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

    r25327 r25956  
    3737
    3838                        %Early return
    39                         if ~ismember('SealevelriseAnalysis',analyses), return; end
    40                         if (strcmp(solution,'TransientSolution') & md.transient.isslr == 0), return; end
     39                        if ~ismember('SealevelchangeAnalysis',analyses), return; end
     40                        if (strcmp(solution,'TransientSolution') & md.transient.isslc == 0), return; end
    4141                        for i=1:length(self.global_average_thermosteric_sea_level_change),
    4242                                md = checkfield(md,'field',self.global_average_thermosteric_sea_level_change{i},'NaN',1,'Inf',1);
    … …  
    4646                        md = checkfield(md,'field',self.modelid,'NaN',1,'Inf',1,'>=',1,'<=',length(self.global_average_thermosteric_sea_level_change));
    4747                        if self.compute_fingerprints,
    48                                 %check geodetic flag of slr is on:
    49                                 if md.solidearth.settings.computesealevelchange==0,
    50                                         error('DSL checkconsistency error message: if bottom pressure fingerprints computations are requested, slr class should have geodetic flag on');
     48                                %check geodetic flag of solidearth is on:
     49                                if md.solidearth.settings.isgrd==0,
     50                                        error('DSL checkconsistency error message: if bottom pressure fingerprints computations are requested, solidearth class should have geodetic flag on');
    5151                                end
    5252                        end

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

    r25772 r25956  
    5555                        if (strcmp(solution,'TransientSolution') & md.transient.isgia) | strcmp(solution,'GiaSolution'),
    5656                                md = checkfield(md,'fieldname','geometry.thickness','timeseries',1,'NaN',1,'Inf',1);
    57                         elseif strcmpi(solution,'SealevelriseSolution'),
     57                        elseif strcmpi(solution,'SealevelchangeSolution'),
    5858                                md = checkfield(md,'fieldname','geometry.bed','NaN',1,'Inf',1,'size',[md.mesh.numberofvertices 1]);
    5959                                return;

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

    r25129 r25956  
    3434
    3535                        %Early return
    36                         if ~ismember('SealevelriseAnalysis',analyses), return; end
    37                         if (strcmp(solution,'TransientSolution') & md.transient.isslr == 0), return; end
     36                        if ~ismember('SealevelchangeAnalysis',analyses), return; end
     37                        if (strcmp(solution,'TransientSolution') & md.transient.isslc == 0), return; end
    3838                        md = checkfield(md,'field',self.Ngia,'NaN',1,'Inf',1);
    3939                        md = checkfield(md,'field',self.Ugia,'NaN',1,'Inf',1);

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

    r25362 r25956  
    4646                function md = checkconsistency(self,md,solution,analyses) % {{{
    4747
    48                         if ~ismember('SealevelriseAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.transient.isslr==0),
     48                        if ~ismember('SealevelchangeAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.transient.isslc==0),
    4949                                return;
    5050                        end

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

    r25169 r25956  
    2929                mantle_density             = 0.;
    3030
    31                 %slr
     31                %slc
    3232                earth_density              = 0;
    3333
    … …  
    127127                                md = checkfield(md,'fieldname','materials.mantle_density','>',0,'numel',1);
    128128                        end
    129                         if ismember('SealevelriseAnalysis',analyses),
     129                        if ismember('SealevelchangeAnalysis',analyses),
    130130                                md = checkfield(md,'fieldname','materials.earth_density','>',0,'numel',1);
    131131                        end

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

    r23702 r25956  
    130130                                md = checkfield(md,'fieldname','materials.mantle_density','>',0,'numel',1);
    131131                        end
    132                         if ismember('SealevelriseAnalysis',analyses),
     132                        if ismember('SealevelchangeAnalysis',analyses),
    133133                                md = checkfield(md,'fieldname','materials.earth_density','>',0,'numel',1);
    134134                        end

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

    r23774 r25956  
    3030                mantle_density             = 0.;
    3131
    32                 %slr
     32                %slc
    3333                earth_density              = 0;
    3434
    … …  
    137137                                md = checkfield(md,'fieldname','materials.mantle_density','>',0,'numel',1);
    138138                        end
    139                         if ismember('SealevelriseAnalysis',analyses),
     139                        if ismember('SealevelchangeAnalysis',analyses),
    140140                                md = checkfield(md,'fieldname','materials.earth_density','>',0,'numel',1);
    141141                        end

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

    r25404 r25956  
    2929                mantle_density             = 0.;
    3030
    31                 %slr
     31                %slc
    3232                earth_density              = 0;
    3333
    … …  
    113113                function md = checkconsistency(self,md,solution,analyses) % {{{
    114114       
    115                         if ~strcmpi(solution,'SealevelriseSolution'),
     115                        if ~strcmpi(solution,'SealevelchangeSolution'),
    116116                                md = checkfield(md,'fieldname','materials.rho_ice','>',0);
    117117                                md = checkfield(md,'fieldname','materials.rho_water','>',0);
    … …  
    130130                                md = checkfield(md,'fieldname','materials.mantle_density','>',0,'numel',1);
    131131                        end
    132                         if ismember('SealevelriseAnalysis',analyses),
     132                        if ismember('SealevelchangeAnalysis',analyses),
    133133                                md = checkfield(md,'fieldname','materials.earth_density','>',0,'numel',1);
    134134                        end

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

    r25947 r25956  
    2424                function md = checkconsistency(self,md,solution,analyses) % {{{
    2525
    26                         if ~ismember('SealevelriseAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.solidearth.settings.isgrd==0),
     26                        if ~ismember('SealevelchangeAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.solidearth.settings.isgrd==0),
    2727                                error('mmeadditionalsolidearthsolution checkconsistency error message: need to run GRD solution if you are supplying a GRD additional pattern solution');
    2828                        end

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

    r25947 r25956  
    2424                function md = checkconsistency(self,md,solution,analyses) % {{{
    2525
    26                         if ~ismember('SealevelriseAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.solidearth.settings.isgrd==1),
     26                        if ~ismember('SealevelchangeAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.solidearth.settings.isgrd==1),
    2727                                error('mmeofflinesolidearthsolution checkconsistency error message: trying to run GRD patterns while supplying an offline solution for those patterns!');
    2828                        end

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

    r25688 r25956  
    33%   Usage:
    44%      nodalvalue=nodalvalue();
    5 %      nodalvalue=nodalvalue('name','SealevelriseSNodalValue',...
     5%      nodalvalue=nodalvalue('name','SealevelchangeSNodalValue',...
    66%                    'definitionstring','Outputdefinition1',
    7 %                    'model_string','SealevelriseS',
     7%                    'model_string','SealevelchangeS',
    88%                    'node',1);
    99

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

    r25947 r25956  
    2121                function md = checkconsistency(self,md,solution,analyses) % {{{
    2222
    23                         if ~ismember('SealevelriseAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.solidearth.settings.isgrd==1),
     23                        if ~ismember('SealevelchangeAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.solidearth.settings.isgrd==1),
    2424                                error('offlinesolidearthsolution checkconsistency error message: trying to run GRD patterns while supplying an offline solution for those patterns!');
    2525                        end

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

    r25688 r25956  
    1414
    1515                %name: name of method, one of 'None','Histogram','SampleSeries' or 'MeanVariance'
    16                 %fields: fields for the  statistics being requested, ex: 'Sealevel','BslrIce','BslrHydro'
     16                %fields: fields for the  statistics being requested, ex: 'Sealevel','BslcIce','BslcHydro'
    1717                %steps: time steps at which each field statistic is computed, ex: [1:2,5,20] or 1:100
    1818                %nbins: number of bins for 'Histogram' statistics

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

    r25152 r25956  
    3030                function md = checkconsistency(self,md,solution,analyses) % {{{
    3131
    32                         if ~ismember('SealevelriseAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.transient.isslr==0),
     32                        if ~ismember('SealevelchangeAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.transient.isslc==0),
    3333                                return;
    3434                        end

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

    r25688 r25956  
    6060                        %check that the transition vectors have the right size:
    6161                        for i=1:length(slm.icecaps),
    62                                 if slm.icecaps{i}.mesh.numberofvertices ~= length(slm.earth.slr.transitions{i}),
     62                                if slm.icecaps{i}.mesh.numberofvertices ~= length(slm.earth.solidearth.transitions{i}),
    6363                                        error(['sealevelmodel checkconsistenty issue with size of transition vector for ice cap: ' num2str(i) ' name: ' slm.icecaps{i}.miscellaneous.name]);
    6464                                end
    … …  
    6767                        %check that run_frequency is the same everywhere:
    6868                        for i=1:length(slm.icecaps),
    69                                 if slm.icecaps{i}.slr.geodetic_run_frequency~=slm.earth.slr.geodetic_run_frequency,
     69                                if slm.icecaps{i}.solidearth.settings.runfrequency~=slm.earth.solidearth.settings.runfrequency,
    7070                                        error(sprintf('sealevelmodel checkconsistenty error:  icecap model %s should have the same run frequency as earth!',slm.icecaps{i}.miscellaneous.name));
    7171                                end
    … …  
    7575                        for i=1:length(slm.icecaps),
    7676                                md= slm.icecaps{i};
    77                                 if ~isempty(find(md.slr.steric_rate - slm.earth.slr.steric_rate(slm.earth.slr.transitions{i}))),
     77                                if ~isempty(find(md.dsl.steric_rate - slm.earth.dsl.steric_rate(slm.earth.dsl.transitions{i}))),
    7878                                        error(sprintf('steric rate on ice cap %s is not the same as for the earth\n',md.miscellaneous.name));
    7979                                end

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

    r25947 r25956  
    5050                function md = checkconsistency(self,md,solution,analyses) % {{{
    5151
    52                         if ~ismember('SealevelriseAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.transient.isslr==0),
     52                        if ~ismember('SealevelchangeAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.transient.isslc==0),
    5353                                return;
    5454                        end

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

    r25767 r25956  
    6060                function md = checkconsistency(self,md,solution,analyses) % {{{
    6161
    62                         if ~ismember('SealevelriseAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.transient.isslr==0),
     62                        if ~ismember('SealevelchangeAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.transient.isslc==0),
    6363                                return;
    6464                        end
    … …  
    9393                        disp(sprintf('   solidearth settings:'));
    9494
    95                         fielddisplay(self,'reltol','sea level rise relative convergence criterion, (default, NaN: not applied)');
    96                         fielddisplay(self,'abstol','sea level rise absolute convergence criterion, NaN: not applied');
     95                        fielddisplay(self,'reltol','sea level change relative convergence criterion, (default, NaN: not applied)');
     96                        fielddisplay(self,'abstol','sea level change absolute convergence criterion, NaN: not applied');
    9797                        fielddisplay(self,'maxiter','maximum number of nonlinear iterations');
    9898                        fielddisplay(self,'ocean_area_scaling','correction for model representation of ocean area [default: No correction]');
    … …  
    123123                function savemodeljs(self,fid,modelname) % {{{
    124124               
    125                         writejsdouble(fid,[modelname '.slr.settings.maxiter'],self.maxiter);
    126                         writejsdouble(fid,[modelname '.slr.settings.reltol'],self.reltol);
    127                         writejsdouble(fid,[modelname '.slr.settings.abstol'],self.abstol);
    128                         writejsdouble(fid,[modelname '.slr.settings.rigid'],self.rigid);
    129                         writejsdouble(fid,[modelname '.slr.settings.elastic'],self.elastic);
    130                         writejsdouble(fid,[modelname '.slr.settings.rotation'],self.rotation);
    131                         writejsdouble(fid,[modelname '.slr.settings.ocean_area_scaling'],self.ocean_area_scaling);
    132                         writejsdouble(fid,[modelname '.slr.settings.run_frequency'],self.run_frequency);
    133                         writejsdouble(fid,[modelname '.slr.settings.degacc'],self.degacc);
    134                         writejsdouble(fid,[modelname '.slr.settings.glfraction'],self.glfraction);
     125                        writejsdouble(fid,[modelname '.solidearth.settings.maxiter'],self.maxiter);
     126                        writejsdouble(fid,[modelname '.solidearth.settings.reltol'],self.reltol);
     127                        writejsdouble(fid,[modelname '.solidearth.settings.abstol'],self.abstol);
     128                        writejsdouble(fid,[modelname '.solidearth.settings.rigid'],self.rigid);
     129                        writejsdouble(fid,[modelname '.solidearth.settings.elastic'],self.elastic);
     130                        writejsdouble(fid,[modelname '.solidearth.settings.rotation'],self.rotation);
     131                        writejsdouble(fid,[modelname '.solidearth.settings.ocean_area_scaling'],self.ocean_area_scaling);
     132                        writejsdouble(fid,[modelname '.solidearth.settings.run_frequency'],self.run_frequency);
     133                        writejsdouble(fid,[modelname '.solidearth.settings.degacc'],self.degacc);
     134                        writejsdouble(fid,[modelname '.solidearth.settings.glfraction'],self.glfraction);
    135135                end % }}}
    136136                function self = extrude(self,md) % {{{

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

    r25221 r25956  
    2828                        function md = checkconsistency(self,md,solution,analyses) % {{{
    2929
    30                         if ~ismember('SealevelriseAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.transient.isslr==0),
     30                        if ~ismember('SealevelchangeAnalysis',analyses) | (strcmp(solution,'TransientSolution') & md.transient.isslc==0),
    3131                                return;
    3232                        end

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

    r25169 r25956  
    105105                                        case 'LoveAnalysis'
    106106                                        case 'EsaAnalysis'
    107                                         case 'SealevelriseAnalysis'
     107                                        case 'SealevelchangeAnalysis'
    108108                                        otherwise
    109109                                                md = checkmessage(md,['md.toolkits.' analyses{i} ' not supported yet']);

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

    r23770 r25956  
    1616                ismovingfront     = 0;
    1717                ishydrology       = 0;
    18                 isslr             = 0;
     18                isslc             = 0;
    1919                iscoupler         = 0;
    2020                amr_frequency     = 0;
    … …  
    4444                        self.ismovingfront   =0;
    4545                        self.ishydrology     = 0;
    46                         self.isslr           = 0;
     46                        self.isslc           = 0;
    4747                        self.isoceancoupling = 0;
    4848                        self.iscoupler       = 0;
    … …  
    6565                        self.ismovingfront   = 0;
    6666                        self.ishydrology     = 0;
    67                         self.isslr           = 0;
     67                        self.isslc           = 0;
    6868                        self.isoceancoupling = 0;
    6969                        self.iscoupler       = 0;
    … …  
    9696                        md = checkfield(md,'fieldname','transient.ishydrology','numel',[1],'values',[0 1]);
    9797                        md = checkfield(md,'fieldname','transient.requested_outputs','stringrow',1);
    98                         md = checkfield(md,'fieldname','transient.isslr','numel',[1],'values',[0 1]);
     98                        md = checkfield(md,'fieldname','transient.isslc','numel',[1],'values',[0 1]);
    9999                        md = checkfield(md,'fieldname','transient.isoceancoupling','numel',[1],'values',[0 1]);
    100100                        md = checkfield(md,'fieldname','transient.iscoupler','numel',[1],'values',[0 1]);
    … …  
    121121                        fielddisplay(self,'ismovingfront','indicates whether a moving front capability is used in the transient');
    122122                        fielddisplay(self,'ishydrology','indicates whether an hydrology model is used');
    123                         fielddisplay(self,'isslr','indicates whether a sea-level rise solution is used in the transient');
     123                        fielddisplay(self,'isslc','indicates whether a sea-level change solution is used in the transient');
    124124                        fielddisplay(self,'isoceancoupling','indicates whether a coupling with an ocean model is used in the transient');
    125125                        fielddisplay(self,'iscoupler','indicates whether different models are being run with need for coupling');
    … …  
    139139                        WriteData(fid,prefix,'object',self,'fieldname','ishydrology','format','Boolean');
    140140                        WriteData(fid,prefix,'object',self,'fieldname','ismovingfront','format','Boolean');
    141                         WriteData(fid,prefix,'object',self,'fieldname','isslr','format','Boolean');
     141                        WriteData(fid,prefix,'object',self,'fieldname','isslc','format','Boolean');
    142142                        WriteData(fid,prefix,'object',self,'fieldname','isoceancoupling','format','Boolean');
    143143                        WriteData(fid,prefix,'object',self,'fieldname','iscoupler','format','Boolean');
    … …  
    165165                        writejsdouble(fid,[modelname '.trans.ismovingfront'],self.ismovingfront);
    166166                        writejsdouble(fid,[modelname '.trans.ishydrology'],self.ishydrology);
    167                         writejsdouble(fid,[modelname '.trans.isslr'],self.isslr);
     167                        writejsdouble(fid,[modelname '.trans.isslc'],self.isslc);
    168168                        writejsdouble(fid,[modelname '.trans.isoceancoupling'],self.isoceancoupling);
    169169                        writejsdouble(fid,[modelname '.trans.iscoupler'],self.iscoupler);

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

    r25168 r25956  
    77%
    88%   solution types available comprise:
    9 %      - 'Sealevelrise'
     9%      - 'Sealevelchange'
    1010%      - 'Transient'
    1111%
    … …  
    1818if strcmpi(solutionstringi,'tr') || strcmpi(solutionstringi,'Transient')
    1919        solutionstring = 'TransientSolution';
    20 elseif strcmpi(solutionstringi,'slr') || strcmpi(solutionstringi,'Sealevelrise')
    21         solutionstring = 'SealevelriseSolution';
     20elseif strcmpi(solutionstringi,'slr') || strcmpi(solutionstringi,'Sealevelchange')
     21        solutionstring = 'SealevelchangeSolution';
    2222else
    2323        error(['solutionstring ' solutionstringi ' not supported!']);

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

    r25762 r25956  
    1515        ids = GetIds('Dakota')
    1616        ids = GetIds([101, 102...])
    17         ids = GetIds([\'Dakota\', \'Slr\'...])
    18         ids = GetIds([[101, 102...], [\'Dakota\', \'Slr\'...]])
     17        ids = GetIds([\'Dakota\', \'Slc\'...])
     18        ids = GetIds([[101, 102...], [\'Dakota\', \'Slc\'...]])
    1919    """
    2020

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

    r25823 r25956  
    2121%                      'qmu'         : validation of dakota tests
    2222%                      'referential' : validation of referential tests
    23 %                      'slr'         : validation of slr tests
     23%                      'slc'         : validation of slc tests
    2424%                      'thermal'     : validation of thermal tests
    2525%                      'tranforcing' : validation of transient forcing tests
    … …  
    5454%GET benchmark {{{
    5555benchmark=getfieldvalue(options,'benchmark','nightly');
    56 if ~ismember(benchmark,{'all','nightly','ismip','eismint','thermal','mesh','validation','tranforcing','adolc','slr','qmu'})
     56if ~ismember(benchmark,{'all','nightly','ismip','eismint','thermal','mesh','validation','tranforcing','adolc','slc','qmu'})
    5757        disp('runme warning: benchmark not supported, defaulting to test ''nightly''')
    5858        benchmark='nightly';
    … …  
    122122elseif strcmpi(benchmark,'referential'),
    123123        test_ids=intersect(test_ids,[1601:1602]);
    124 elseif strcmpi(benchmark,'slr'),
     124elseif strcmpi(benchmark,'slc'),
    125125        test_ids=intersect(test_ids,[2001:2500]);
    126126elseif strcmpi(benchmark,'adolc'),

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

    r25762 r25956  
    4747                            'qmu'           : validation of qmu tests
    4848                            'referential'   : validation of referential tests
    49                             'slr'           : validation of slr tests
     49                            'slc'           : validation of slc tests
    5050                            'thermal'       : validation of thermal tests
    5151                            'tranforcing'   : validation of transient forcing tests
    … …  
    6363        ./runme.py -e 2001
    6464        ./runme.py -e 'Dakota' --benchmark 'all'
    65         ./runme.py -i [[101, 102], ['Dakota', 'Slr']]
     65        ./runme.py -i [[101, 102], ['Dakota', 'Slc']]
    6666
    6767    TODO:
    … …  
    7676    #Process options
    7777    #GET benchmark {{{
    78     if benchmark not in ['all', 'nightly', 'validation', 'adolc', 'eismint', 'ismip', 'mesh', 'slr', 'thermal', 'tranforcing', 'qmu']:
     78    if benchmark not in ['all', 'nightly', 'validation', 'adolc', 'eismint', 'ismip', 'mesh', 'slc', 'thermal', 'tranforcing', 'qmu']:
    7979        print(("runme warning: benchmark '{}' not supported, defaulting to test 'nightly'.".format(benchmark)))
    8080        benchmark = 'nightly'
    … …  
    129129    elif benchmark == 'referential':
    130130        test_ids = test_ids.intersection(set(range(1601, 1603)))
    131     elif benchmark == 'slr':
     131    elif benchmark == 'slc':
    132132        test_ids = test_ids.intersection(set(range(2001, 2500)))
    133133    elif benchmark == 'adolc':

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

    r25948 r25956  
    1 %Test Name: EarthSlr
     1%Test Name: EarthSlc
    22
    33%mesh earth:

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

    r25763 r25956  
    1 #Test Name: EarthSlr
     1#Test Name: EarthSlc
    22import numpy as np
    33

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

    r25948 r25956  
    1 %Test Name: EarthSlr_rotationalFeedback
     1%Test Name: EarthSlc_rotationalFeedback
    22
    33%mesh earth:
    … …  
    55md.mesh=gmshplanet('radius',6.371012*10^3,'resolution',1000.); %1000 km resolution mesh
    66
    7 %parameterize slr solution:
     7%parameterize slc solution:
    88%solidearth loading:  {{{
    99md.solidearth.surfaceload.icethicknesschange=zeros(md.mesh.numberofelements,1);

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

    r25763 r25956  
    1 #Test Name: EarthSlr_rotationalFeedback
     1#Test Name: EarthSlc_rotationalFeedback
    22import numpy as np
    33

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

    r25948 r25956  
    135135                md.geometry.bed=-ones(md.mesh.numberofvertices,1);
    136136        end % }}}
    137         %Slr: {{{
     137        %Slc: {{{
    138138        if bas.iscontinentany('antarctica'),
    139139                if testagainst2002,
    … …  
    244244        % }}}
    245245        %}}}
    246         %slr loading/calibration:  {{{
     246        %slc loading/calibration:  {{{
    247247        md.solidearth.surfaceload.icethicknesschange=zeros(md.mesh.numberofelements,1);
    248248

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

    r25763 r25956  
    1 %Test Name: EarthSlr
     1%Test Name: EarthSlc
    22
    33%mesh earth:
    … …  
    7272md.timestepping.final_time=10;
    7373md.timestepping.time_step=1;
    74 md.transient.isslr=1;
     74md.transient.isslc=1;
    7575md.transient.issmb=0;
    7676md.transient.isgia=1;
    … …  
    9797S5=md.results.TransientSolution(5).Sealevel;
    9898S10=md.results.TransientSolution(10).Sealevel;
    99 Seus10=md.results.TransientSolution(10).Bslr;
     99Seus10=md.results.TransientSolution(10).Bslc;
    100100
    101101%Fields and tolerances to track changes

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

    r25763 r25956  
    1 #Test Name: EarthSlr
     1#Test Name: EarthSlc
    22import numpy as np
    33
    … …  
    8484md.timestepping.final_time = 10
    8585md.timestepping.time_step = 1
    86 md.transient.isslr = 1
     86md.transient.isslc = 1
    8787md.transient.issmb = 0
    8888md.transient.isgia = 1
    … …  
    109109S5 = md.results.TransientSolution[5 - 1].Sealevel
    110110S10 = md.results.TransientSolution[10 - 1].Sealevel
    111 Seus10 = md.results.TransientSolution[10 - 1].Bslr
     111Seus10 = md.results.TransientSolution[10 - 1].Bslc
    112112
    113113#Fields and tolerances to track changes

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

    r25763 r25956  
    1 %Test Name: EarthSlr Dakota Sampling glaciers.
     1%Test Name: EarthSlc Dakota Sampling glaciers.
    22
    33%mesh earth:
    … …  
    7373md.timestepping.final_time=10;
    7474md.timestepping.time_step=1;
    75 md.transient.isslr=1;
     75md.transient.isslc=1;
    7676md.transient.issmb=0;
    7777md.transient.isgia=1;
    … …  
    161161
    162162md.qmu.statistics.method(1).name='Histogram';
    163 md.qmu.statistics.method(1).fields={'Sealevel','BslrIce'};
     163md.qmu.statistics.method(1).fields={'Sealevel','BslcIce'};
    164164md.qmu.statistics.method(1).steps=[1:10];
    165165md.qmu.statistics.method(1).nbins=20;
    166166
    167167md.qmu.statistics.method(2).name='MeanVariance';
    168 md.qmu.statistics.method(2).fields={'Sealevel','BslrIce'};
     168md.qmu.statistics.method(2).fields={'Sealevel','BslcIce'};
    169169md.qmu.statistics.method(2).steps=[1:10];
    170170
    171171md.qmu.statistics.method(3).name='SampleSeries';
    172 md.qmu.statistics.method(3).fields={'Sealevel','BslrIce'};
     172md.qmu.statistics.method(3).fields={'Sealevel','BslcIce'};
    173173md.qmu.statistics.method(3).steps=[1:10];
    174174md.qmu.statistics.method(3).indices=locations;

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

    r25763 r25956  
    1 #Test Name: EarthSlr Dakota Sampling glaciers
     1#Test Name: EarthSlc Dakota Sampling glaciers
    22import numpy as np
    33
    … …  
    8787md.timestepping.final_time = 10
    8888md.timestepping.time_step = 1
    89 md.transient.isslr = 1
     89md.transient.isslc = 1
    9090md.transient.issmb = 0
    9191md.transient.isgia = 1
    … …  
    195195
    196196md.qmu.statistics.method[0]['name'] = 'Histogram'
    197 md.qmu.statistics.method[0]['fields'] = ['Sealevel', 'BslrIce']
     197md.qmu.statistics.method[0]['fields'] = ['Sealevel', 'BslcIce']
    198198md.qmu.statistics.method[0]['steps'] = np.arange(1, 10 + 1).reshape(1, -1)
    199199md.qmu.statistics.method[0]['nbins'] = 20
    … …  
    201201md.qmu.statistics.addmethod()
    202202md.qmu.statistics.method[1]['name'] = 'MeanVariance'
    203 md.qmu.statistics.method[1]['fields'] = ['Sealevel', 'BslrIce']
     203md.qmu.statistics.method[1]['fields'] = ['Sealevel', 'BslcIce']
    204204md.qmu.statistics.method[1]['steps'] = np.arange(1, 10 + 1).reshape(1, -1)
    205205
    206206md.qmu.statistics.addmethod()
    207207md.qmu.statistics.method[2]['name'] = 'SampleSeries'
    208 md.qmu.statistics.method[2]['fields'] = ['Sealevel', 'BslrIce']
     208md.qmu.statistics.method[2]['fields'] = ['Sealevel', 'BslcIce']
    209209md.qmu.statistics.method[2]['steps'] = np.arange(1, 10 + 1).reshape(1, -1)
    210210md.qmu.statistics.method[2]['indices'] = locations.reshape(1, -1)

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

    r25951 r25956  
    66md.mesh=gmshplanet('radius',rad_e,'resolution',1000.0);  % km resolution
    77
    8 %parameterize slr solution:
    9 %slr loading:  {{{
     8%parameterize slc solution:
     9%slc loading:  {{{
    1010late=sum(md.mesh.lat(md.mesh.elements),2)/3;
    1111longe=sum(md.mesh.long(md.mesh.elements),2)/3;
    … …  
    7575% uncomment following 2 lines for
    7676md=solve(md,'Sealevelchange');
    77 eus=md.results.SealevelchangeSolution.Bslr;
    78 slr=md.results.SealevelchangeSolution.Sealevel;
     77eus=md.results.SealevelchangeSolution.Bslc;
     78slc=md.results.SealevelchangeSolution.Sealevel;
    7979moixz=md.results.SealevelchangeSolution.SealevelInertiaTensorXZ;
    8080moiyz=md.results.SealevelchangeSolution.SealevelInertiaTensorYZ;
    … …  
    8282
    8383% analytical moi => just checking FOR ICE only!!! {{{
    84 % ...have to mute ** slr induced MOI in Tria.cpp ** prior to the comparison
     84% ...have to mute ** slc induced MOI in Tria.cpp ** prior to the comparison
    8585%rad_e = rad_e*1e3; % now in meters
    8686%areas=GetAreasSphericalTria(md.mesh.elements,md.mesh.lat,md.mesh.long,rad_e);
    … …  
    9191
    9292%Fields and tolerances to track changes
    93 field_names     ={'eus','slr','moixz','moiyz','moizz'};
     93field_names     ={'eus','slc','moixz','moiyz','moizz'};
    9494field_tolerances={1e-13,1e-13,1e-13,1e-13,1e-13};
    95 field_values={eus,slr,moixz,moiyz,moizz};
     95field_values={eus,slc,moixz,moiyz,moizz};
    9696

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

    r25763 r25956  
    8787# uncomment following 2 lines for
    8888md = solve(md, 'Sealevelrise')
    89 eus = md.results.SealevelriseSolution.Bslr
    90 slr = md.results.SealevelriseSolution.Sealevel
     89eus = md.results.SealevelriseSolution.Bslc
     90slc = md.results.SealevelriseSolution.Sealevel
    9191moixz = md.results.SealevelriseSolution.SealevelInertiaTensorXZ
    9292moiyz = md.results.SealevelriseSolution.SealevelInertiaTensorYZ
    … …  
    103103
    104104#Fields and tolerances to track changes
    105 field_names = ['eus', 'slr', 'moixz', 'moiyz', 'moizz']
     105field_names = ['eus', 'slc', 'moixz', 'moiyz', 'moizz']
    106106field_tolerances = [1e-13, 1e-13, 1e-13, 1e-13, 1e-13]
    107 field_values = [eus, slr, moixz, moiyz, moizz]
     107field_values = [eus, slc, moixz, moiyz, moizz]

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

    r25475 r25956  
    1 %Test Name: SHslr
     1%Test Name: SHslc
    22% spherical-harmonic (SH) approach for solving the sea-level equation.
    33% reference: Adhikari et al., 2019, ESSD, https://doi.org/10.5194/essd-11-629-2019

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

    r25428 r25956  
    1 %Test Name: SESAWslr
    2 % SESAW method of solving GRD slr
     1%Test Name: SESAWslc
     2% SESAW method of solving GRD slc
    33% reference: Adhikari et al., 2016, GMD, https://doi.org/10.5194/gmd-9-1087-2016
    44
    … …  
    3636area_element=GetAreasSphericalTria(md.mesh.elements,md.mesh.lat,md.mesh.long,md.solidearth.planetradius);
    3737
    38 % Parameters input for SESAWslr solver.
     38% Parameters input for SESAWslc solver.
    3939para.ocean_element = ocean_element;
    4040para.loads_element = loads_element;
    … …  
    6161
    6262% solve: Rigid without rotational feedbacks.
    63 disp(['Solving sesaw-slr for Rigid Earth WITHOUT rotational feedback...']);
     63disp(['Solving sesaw-slc for Rigid Earth WITHOUT rotational feedback...']);
    6464[eus_rigid,rsl_rigid] = SESAWslr(md.mesh.elements,md.mesh.lat,md.mesh.long,greens,para);
    6565
    6666% solve: Rigid with rotational feedbacks.
    6767para.rotational.flag = 1;
    68 disp(['Solving sesaw-slr for Rigid Earth WITH rotational feedback...']);
     68disp(['Solving sesaw-slc for Rigid Earth WITH rotational feedback...']);
    6969[eus_rigid_rot,rsl_rigid_rot] = SESAWslr(md.mesh.elements,md.mesh.lat,md.mesh.long,greens,para);
    7070
    7171% solve: Elastic with rotational feedbacks.
    7272para.solidearth = 'elastic';
    73 disp(['Solving sesaw-slr for Elastic Earth WITH rotational feedback...']);
     73disp(['Solving sesaw-slc for Elastic Earth WITH rotational feedback...']);
    7474[eus_elast_rot,rsl_elast_rot] = SESAWslr(md.mesh.elements,md.mesh.lat,md.mesh.long,greens,para);
    7575
    7676% solve: Elastic with rotational feedbacks.
    7777para.rotational.flag = 0;
    78 disp(['Solving sesaw-slr for Elastic Earth WITHOUT rotational feedback...']);
     78disp(['Solving sesaw-slc for Elastic Earth WITHOUT rotational feedback...']);
    7979[eus_elast,rsl_elast] = SESAWslr(md.mesh.elements,md.mesh.lat,md.mesh.long,greens,para);
    8080
Note: See TracChangeset for help on using the changeset viewer.