Changeset 25947


Ignore:
Timestamp:
01/25/21 16:35:15 (4 years ago)
Author:
Eric.Larour
Message:

CHG: created external forcings for solid earth. Completely reorganized the sealevel change
core (in particular now we have a clean split between the external forcings, the grd core
and the dynamic steric core). Also, we reorganized and renamed the grd components and cores.
From eutatic, we now have: barystatic core, sal core, deformation core. No more diagnostics.
We also allow the external forcings to be mmes. Lots of cosmetic name changes (rise->change
for ex.).

Location:
issm/trunk-jpl/src
Files:
6 added
2 deleted
27 edited

Legend:

Unmodified
Added
Removed

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

    r25840 r25947  
    552552issm_sources += \
    553553        ./cores/sealevelchange_core.cpp \
    554         ./analyses/SealevelriseAnalysis.cpp
     554        ./analyses/SealevelchangeAnalysis.cpp
    555555endif
    556556#}}}

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

    r25066 r25947  
    105105                #endif
    106106                #ifdef _HAVE_SEALEVELRISE_
    107                 case SealevelriseAnalysisEnum : return new SealevelriseAnalysis();
     107                case SealevelchangeAnalysisEnum : return new SealevelchangeAnalysis();
    108108                #endif
    109109                #ifdef _HAVE_SMB_

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

    r25833 r25947  
    156156        if(isgroundingline)     iomodel->FetchDataToInput(inputs,elements,"md.geometry.bed",BedEnum);
    157157        /*Initialize cumdeltalthickness input*/
    158         InputUpdateFromConstantx(inputs,elements,0.,SealevelriseCumDeltathicknessEnum);
     158        InputUpdateFromConstantx(inputs,elements,0.,SealevelchangeCumDeltathicknessEnum);
    159159        /*Initialize ThicknessResidual input*/
    160160        InputUpdateFromConstantx(inputs,elements,0.,ThicknessResidualEnum);
    … …  
    856856        basalelement->GetInputListOnVertices(&phi[0],MaskOceanLevelsetEnum);
    857857        basalelement->GetInputListOnVertices(&sealevel[0],SealevelEnum);
    858         basalelement->GetInputListOnVertices(&cumdeltathickness[0],SealevelriseCumDeltathicknessOldEnum);
     858        basalelement->GetInputListOnVertices(&cumdeltathickness[0],SealevelchangeCumDeltathicknessOldEnum);
    859859
    860860        /*Do we do grounding line migration?*/
    … …  
    863863        if(isgroundingline) basalelement->GetInputListOnVertices(&bed[0],BedEnum);
    864864
    865         /*What is the delta thickness forcing the sea-level rise core: cumulated over time, hence the +=:*/
     865        /*What is the delta thickness forcing the sea-level change core: cumulated over time, hence the +=:*/
    866866        for(int i=0;i<numvertices;i++){
    867867                cumdeltathickness[i] += newthickness[i]-oldthickness[i];
    … …  
    902902        element->AddBasalInput(SurfaceEnum,newsurface,P1Enum);
    903903        element->AddBasalInput(BaseEnum,newbase,P1Enum);
    904         element->AddBasalInput(SealevelriseCumDeltathicknessEnum,cumdeltathickness,P1Enum);
     904        element->AddBasalInput(SealevelchangeCumDeltathicknessEnum,cumdeltathickness,P1Enum);
    905905        element->AddBasalInput(SurfaceloadIceThicknessChangeEnum,deltathickness,P1Enum);
    906906

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

    r25066 r25947  
    3636#include "./MasstransportAnalysis.h"
    3737#include "./SmbAnalysis.h"
    38 #include "./SealevelriseAnalysis.h"
     38#include "./SealevelchangeAnalysis.h"
    3939#include "./MeltingAnalysis.h"
    4040#include "./SmoothAnalysis.h"

  • issm/trunk-jpl/src/c/classes/Dakota/IssmParallelDirectApplicInterface.cpp

    r24986 r25947  
    9595
    9696                /*Hack:*/
    97                 for(int i=0;i<femmodel_init->nummodels;i++) if(femmodel_init->analysis_type_list[i]==SealevelriseAnalysisEnum) sealevelrise_core_geometry(femmodel_init);
     97                for(int i=0;i<femmodel_init->nummodels;i++) if(femmodel_init->analysis_type_list[i]==SealevelchangeAnalysisEnum) sealevelchange_geometry(femmodel_init);
    9898
    9999                /*Make a copy of femmodel, so we start this new evaluation run for this specific sample with a brand

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

    r25839 r25947  
    377377                virtual IssmDouble    GetAreaSpherical(void)=0;
    378378                virtual IssmDouble    OceanAverage(IssmDouble* Sg, SealevelMasks* masks)=0;
    379                 virtual void          SealevelriseMomentOfInertia(IssmDouble* dI_list,IssmDouble* Sg_old, SealevelMasks* masks)=0;
    380                 virtual IssmDouble    SealevelriseEustaticIce(IssmDouble* Sgi, SealevelMasks* masks,Vector<IssmDouble>* barystatic_contribution,IssmDouble* partition,IssmDouble oceanarea)=0;
    381                 virtual IssmDouble    SealevelriseEustaticHydro(IssmDouble* Sgi, SealevelMasks* masks,Vector<IssmDouble>* barystatic_contribution, IssmDouble* partition, IssmDouble oceanarea)=0;
    382                 virtual void          SealevelriseEustaticBottomPressure(IssmDouble* Sgi, SealevelMasks* masks)=0;
    383                 virtual void          SealevelriseGeometry(IssmDouble* latitude,IssmDouble* longitude,IssmDouble* radius,IssmDouble* xx, IssmDouble* yy, IssmDouble* zz)=0;
    384                 virtual void          SealevelriseNonEustatic(IssmDouble* Sgo, IssmDouble* Sg_old,SealevelMasks* mask)=0;
    385                 virtual void          SealevelriseGeodetic(IssmDouble* Up, IssmDouble* North, IssmDouble* East, IssmDouble* Sg,SealevelMasks* masks)=0;
     379                virtual void          SealevelchangeMomentOfInertia(IssmDouble* dI_list,IssmDouble* Sg_old, SealevelMasks* masks)=0;
     380                virtual IssmDouble    SealevelchangeBarystaticIce(IssmDouble* Sgi, SealevelMasks* masks,Vector<IssmDouble>* barystatic_contribution,IssmDouble* partition,IssmDouble oceanarea)=0;
     381                virtual IssmDouble    SealevelchangeBarystaticHydro(IssmDouble* Sgi, SealevelMasks* masks,Vector<IssmDouble>* barystatic_contribution, IssmDouble* partition, IssmDouble oceanarea)=0;
     382                virtual void          SealevelchangeBarystaticBottomPressure(IssmDouble* Sgi, SealevelMasks* masks)=0;
     383                virtual void          SealevelchangeGeometry(IssmDouble* latitude,IssmDouble* longitude,IssmDouble* radius,IssmDouble* xx, IssmDouble* yy, IssmDouble* zz)=0;
     384                virtual void          SealevelchangeSal(IssmDouble* Sgo, IssmDouble* Sg_old,SealevelMasks* mask)=0;
     385                virtual void          DeformationFromSurfaceLoads(IssmDouble* Up, IssmDouble* North, IssmDouble* East, IssmDouble* Sg,SealevelMasks* masks)=0;
    386386                #endif
    387387

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

    r25839 r25947  
    216216                IssmDouble    OceanAverage(IssmDouble* Sg, SealevelMasks* masks){_error_("not implemented yet!");};
    217217                void    SetSealevelMasks(SealevelMasks* masks){_error_("not implemented yet!");};
    218                 void    SealevelriseMomentOfInertia(IssmDouble* dI_list,IssmDouble* Sg_old, SealevelMasks* masks){_error_("not implemented yet!");};
    219                 void    SealevelriseGeometry(IssmDouble* latitude,IssmDouble* longitude,IssmDouble* radius,IssmDouble* xx, IssmDouble* yy, IssmDouble* zz){_error_("not implemented yet!");};
    220                 IssmDouble    SealevelriseEustaticIce(IssmDouble* Sgi, SealevelMasks* masks, Vector<IssmDouble>* barystatic_contribution, IssmDouble* partition, IssmDouble oceanarea){_error_("not implemented yet!");};
    221                 IssmDouble    SealevelriseEustaticHydro(IssmDouble* Sgi, SealevelMasks* masks, Vector<IssmDouble>* barystatic_contribution, IssmDouble* partition,IssmDouble oceanarea){_error_("not implemented yet!");};
    222                 void    SealevelriseEustaticBottomPressure(IssmDouble* Sgi,SealevelMasks* masks){_error_("not implemented yet!");};
    223                 void    SealevelriseNonEustatic(IssmDouble* Sgo, IssmDouble* Sg_old, SealevelMasks* masks){_error_("not implemented yet!");};
    224                 void    SealevelriseGeodetic(IssmDouble* Up, IssmDouble* North, IssmDouble* East, IssmDouble* Sg, SealevelMasks* masks){_error_("not implemented yet!");};
     218                void    SealevelchangeMomentOfInertia(IssmDouble* dI_list,IssmDouble* Sg_old, SealevelMasks* masks){_error_("not implemented yet!");};
     219                void    SealevelchangeGeometry(IssmDouble* latitude,IssmDouble* longitude,IssmDouble* radius,IssmDouble* xx, IssmDouble* yy, IssmDouble* zz){_error_("not implemented yet!");};
     220                IssmDouble    SealevelchangeBarystaticIce(IssmDouble* Sgi, SealevelMasks* masks, Vector<IssmDouble>* barystatic_contribution, IssmDouble* partition, IssmDouble oceanarea){_error_("not implemented yet!");};
     221                IssmDouble    SealevelchangeBarystaticHydro(IssmDouble* Sgi, SealevelMasks* masks, Vector<IssmDouble>* barystatic_contribution, IssmDouble* partition,IssmDouble oceanarea){_error_("not implemented yet!");};
     222                void    SealevelchangeBarystaticBottomPressure(IssmDouble* Sgi,SealevelMasks* masks){_error_("not implemented yet!");};
     223                void    SealevelchangeSal(IssmDouble* Sgo, IssmDouble* Sg_old, SealevelMasks* masks){_error_("not implemented yet!");};
     224                void    DeformationFromSurfaceLoads(IssmDouble* Up, IssmDouble* North, IssmDouble* East, IssmDouble* Sg, SealevelMasks* masks){_error_("not implemented yet!");};
    225225                #endif
    226226

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

    r25752 r25947  
    170170#endif
    171171#ifdef _HAVE_SEALEVELRISE_
    172                 void    SealevelriseMomentOfInertia(IssmDouble* dI_list,IssmDouble* Sg_old, SealevelMasks* masks){_error_("not implemented yet!");};
     172                void    SealevelchangeMomentOfInertia(IssmDouble* dI_list,IssmDouble* Sg_old, SealevelMasks* masks){_error_("not implemented yet!");};
    173173                void    SetSealevelMasks(SealevelMasks* masks){_error_("not implemented yet!");};
    174                 void    SealevelriseGeometry(IssmDouble* latitude,IssmDouble* longitude,IssmDouble* radius,IssmDouble* xx, IssmDouble* yy, IssmDouble* zz){_error_("not implemented yet!");};
    175                 IssmDouble    SealevelriseEustaticIce(IssmDouble* Sgi, SealevelMasks* masks, Vector<IssmDouble>* barystatic_contribution, IssmDouble* partition, IssmDouble oceanarea){_error_("not implemented yet!");};
    176                 IssmDouble    SealevelriseEustaticHydro(IssmDouble* Sgi, SealevelMasks* masks, Vector<IssmDouble>* barystatic_contribution, IssmDouble* partition,IssmDouble oceanarea){_error_("not implemented yet!");};
    177                 void    SealevelriseEustaticBottomPressure(IssmDouble* Sgi,SealevelMasks* masks){_error_("not implemented yet!");};
    178                 void    SealevelriseNonEustatic(IssmDouble* Sgo,IssmDouble* Sg_old, SealevelMasks* masks){_error_("not implemented yet!");};
    179                 void    SealevelriseGeodetic(IssmDouble* Up, IssmDouble* North, IssmDouble* East, IssmDouble* Sg, SealevelMasks* masks){_error_("not implemented yet!");};
     174                void    SealevelchangeGeometry(IssmDouble* latitude,IssmDouble* longitude,IssmDouble* radius,IssmDouble* xx, IssmDouble* yy, IssmDouble* zz){_error_("not implemented yet!");};
     175                IssmDouble    SealevelchangeBarystaticIce(IssmDouble* Sgi, SealevelMasks* masks, Vector<IssmDouble>* barystatic_contribution, IssmDouble* partition, IssmDouble oceanarea){_error_("not implemented yet!");};
     176                IssmDouble    SealevelchangeBarystaticHydro(IssmDouble* Sgi, SealevelMasks* masks, Vector<IssmDouble>* barystatic_contribution, IssmDouble* partition,IssmDouble oceanarea){_error_("not implemented yet!");};
     177                void    SealevelchangeBarystaticBottomPressure(IssmDouble* Sgi,SealevelMasks* masks){_error_("not implemented yet!");};
     178                void    SealevelchangeSal(IssmDouble* Sgo,IssmDouble* Sg_old, SealevelMasks* masks){_error_("not implemented yet!");};
     179                void    DeformationFromSurfaceLoads(IssmDouble* Up, IssmDouble* North, IssmDouble* East, IssmDouble* Sg, SealevelMasks* masks){_error_("not implemented yet!");};
    180180                IssmDouble    OceanAverage(IssmDouble* Sg, SealevelMasks* masks){_error_("not implemented yet!");};
    181181#endif

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

    r25752 r25947  
    177177#ifdef _HAVE_SEALEVELRISE_
    178178                void    SetSealevelMasks(SealevelMasks* masks){_error_("not implemented yet!");};
    179                 void    SealevelriseMomentOfInertia(IssmDouble* dI_list,IssmDouble* Sg_old, SealevelMasks* masks){_error_("not implemented yet!");};
    180                 void    SealevelriseGeometry(IssmDouble* latitude,IssmDouble* longitude,IssmDouble* radius,IssmDouble* xx, IssmDouble* yy, IssmDouble* zz){_error_("not implemented yet!");};
    181                 IssmDouble    SealevelriseEustaticIce(IssmDouble* Sgi, SealevelMasks* masks, Vector<IssmDouble>* barystatic_contribution, IssmDouble* partition, IssmDouble oceanarea){_error_("not implemented yet!");};
    182                 IssmDouble    SealevelriseEustaticHydro(IssmDouble* Sgi, SealevelMasks* masks, Vector<IssmDouble>* barystatic_contribution, IssmDouble* partition,IssmDouble oceanarea){_error_("not implemented yet!");};
    183                 void    SealevelriseEustaticBottomPressure(IssmDouble* Sgi,SealevelMasks* masks){_error_("not implemented yet!");};
    184                 void    SealevelriseNonEustatic(IssmDouble* Sgo, IssmDouble* Sg_old, SealevelMasks* masks){_error_("not implemented yet!");};
    185                 void    SealevelriseGeodetic(IssmDouble* Up ,IssmDouble* North, IssmDouble* East, IssmDouble* Sg, SealevelMasks* masks){_error_("not implemented yet!");};
     179                void    SealevelchangeMomentOfInertia(IssmDouble* dI_list,IssmDouble* Sg_old, SealevelMasks* masks){_error_("not implemented yet!");};
     180                void    SealevelchangeGeometry(IssmDouble* latitude,IssmDouble* longitude,IssmDouble* radius,IssmDouble* xx, IssmDouble* yy, IssmDouble* zz){_error_("not implemented yet!");};
     181                IssmDouble    SealevelchangeBarystaticIce(IssmDouble* Sgi, SealevelMasks* masks, Vector<IssmDouble>* barystatic_contribution, IssmDouble* partition, IssmDouble oceanarea){_error_("not implemented yet!");};
     182                IssmDouble    SealevelchangeBarystaticHydro(IssmDouble* Sgi, SealevelMasks* masks, Vector<IssmDouble>* barystatic_contribution, IssmDouble* partition,IssmDouble oceanarea){_error_("not implemented yet!");};
     183                void    SealevelchangeBarystaticBottomPressure(IssmDouble* Sgi,SealevelMasks* masks){_error_("not implemented yet!");};
     184                void    SealevelchangeSal(IssmDouble* Sgo, IssmDouble* Sg_old, SealevelMasks* masks){_error_("not implemented yet!");};
     185                void    DeformationFromSurfaceLoads(IssmDouble* Up ,IssmDouble* North, IssmDouble* East, IssmDouble* Sg, SealevelMasks* masks){_error_("not implemented yet!");};
    186186                IssmDouble    OceanAverage(IssmDouble* Sg, SealevelMasks* masks){_error_("not implemented yet!");};
    187187#endif

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

    r25942 r25947  
    53875387        this->parameters->FindParam(&gsize,MeshNumberofverticesEnum);
    53885388
    5389         /*Get area of element: precomputed in the sealevelrise_core_geometry:*/
     5389        /*Get area of element: precomputed in the sealevelchange_geometry:*/
    53905390        area=GetAreaSpherical();
    53915391
    … …  
    55225522}
    55235523/*}}}*/
    5524 void    Tria::SealevelriseMomentOfInertia(IssmDouble* dI_list,IssmDouble* Sg_old, SealevelMasks* masks){/*{{{*/
     5524void    Tria::SealevelchangeMomentOfInertia(IssmDouble* dI_list,IssmDouble* Sg_old, SealevelMasks* masks){/*{{{*/
    55255525        /*early return if we are not on an ice cap OR ocean:*/
    55265526        if(!masks->isiceonly[this->lid] && !masks->isoceanin[this->lid]){
    … …  
    55865586                rho_water=FindParam(MaterialsRhoSeawaterEnum);
    55875587
    5588                 /*From Sg_old, recover water sea level rise:*/
     5588                /*From Sg_old, recover water sea level change:*/
    55895589                S=0; for(int i=0;i<NUMVERTICES;i++) S+=Sg_old[this->vertices[i]->Sid()]/NUMVERTICES;
    55905590
    … …  
    56065606                /*Compute ice thickness change: */
    56075607                Input* deltathickness_input=this->GetInput(SurfaceloadIceThicknessChangeEnum);
    5608                 if (!deltathickness_input)_error_("delta thickness input needed to compute sea level rise!");
     5608                if (!deltathickness_input)_error_("delta thickness input needed to compute sea level change!");
    56095609                deltathickness_input->GetInputAverage(&I);
    56105610
    … …  
    56325632}
    56335633/*}}}*/
    5634 void    Tria::SealevelriseGeometry(IssmDouble* latitude,IssmDouble* longitude,IssmDouble* radius, IssmDouble* xx, IssmDouble* yy, IssmDouble* zz){ /*{{{*/
     5634void    Tria::SealevelchangeGeometry(IssmDouble* latitude,IssmDouble* longitude,IssmDouble* radius, IssmDouble* xx, IssmDouble* yy, IssmDouble* zz){ /*{{{*/
    56355635        /*diverse:*/
    56365636        int gsize;
    … …  
    56935693
    56945694        /*recover precomputed green function kernels:*/
    5695         DoubleVecParam* parameter = static_cast<DoubleVecParam*>(this->parameters->FindParamObject(SealevelriseGRigidEnum)); _assert_(parameter);
     5695        DoubleVecParam* parameter = static_cast<DoubleVecParam*>(this->parameters->FindParamObject(SealevelchangeGRigidEnum)); _assert_(parameter);
    56965696        parameter->GetParameterValueByPointer((IssmDouble**)&G_rigid_precomputed,&M);
    56975697
    … …  
    57015701
    57025702        if(computeelastic){
    5703                 parameter = static_cast<DoubleVecParam*>(this->parameters->FindParamObject(SealevelriseGElasticEnum)); _assert_(parameter);
     5703                parameter = static_cast<DoubleVecParam*>(this->parameters->FindParamObject(SealevelchangeGElasticEnum)); _assert_(parameter);
    57045704                parameter->GetParameterValueByPointer((IssmDouble**)&G_elastic_precomputed,&M);
    57055705
    5706                 parameter = static_cast<DoubleVecParam*>(this->parameters->FindParamObject(SealevelriseHElasticEnum)); _assert_(parameter);
     5706                parameter = static_cast<DoubleVecParam*>(this->parameters->FindParamObject(SealevelchangeHElasticEnum)); _assert_(parameter);
    57075707                parameter->GetParameterValueByPointer((IssmDouble**)&H_elastic_precomputed,&M);
    57085708
    5709                 parameter = static_cast<DoubleVecParam*>(this->parameters->FindParamObject(SealevelriseUElasticEnum)); _assert_(parameter);
     5709                parameter = static_cast<DoubleVecParam*>(this->parameters->FindParamObject(SealevelchangeUElasticEnum)); _assert_(parameter);
    57105710                parameter->GetParameterValueByPointer((IssmDouble**)&U_elastic_precomputed,&M);
    57115711
    … …  
    57755775
    57765776        /*Add in inputs:*/
    5777         this->inputs->SetArrayInput(SealevelriseIndicesEnum,this->lid,indices,gsize);
    5778         this->inputs->SetArrayInput(SealevelriseGEnum,this->lid,G,gsize);
     5777        this->inputs->SetArrayInput(SealevelchangeIndicesEnum,this->lid,indices,gsize);
     5778        this->inputs->SetArrayInput(SealevelchangeGEnum,this->lid,G,gsize);
    57795779        if(computeelastic){
    5780                 this->inputs->SetArrayInput(SealevelriseGUEnum,this->lid,GU,gsize);
     5780                this->inputs->SetArrayInput(SealevelchangeGUEnum,this->lid,GU,gsize);
    57815781                if(horiz){
    5782                         this->inputs->SetArrayInput(SealevelriseGNEnum,this->lid,GN,gsize);
    5783                         this->inputs->SetArrayInput(SealevelriseGEEnum,this->lid,GE,gsize);
     5782                        this->inputs->SetArrayInput(SealevelchangeGNEnum,this->lid,GN,gsize);
     5783                        this->inputs->SetArrayInput(SealevelchangeGEEnum,this->lid,GE,gsize);
    57845784                }
    57855785        }
    … …  
    58135813}
    58145814/*}}}*/
    5815 IssmDouble Tria::SealevelriseEustaticIce(IssmDouble* Sgi, SealevelMasks* masks, Vector<IssmDouble>* barystatic_contribution, IssmDouble* partition, IssmDouble oceanarea){ /*{{{*/
     5815IssmDouble Tria::SealevelchangeBarystaticIce(IssmDouble* Sgi, SealevelMasks* masks, Vector<IssmDouble>* barystatic_contribution, IssmDouble* partition, IssmDouble oceanarea){ /*{{{*/
    58165816
    58175817        /*diverse:*/
    58185818        int gsize;
    58195819        IssmDouble area;
    5820         IssmDouble phi=1.0; //WARNING: do not touch this, default is entire elemnt contributes eustatic
     5820        IssmDouble phi=1.0; //WARNING: do not touch this, default is entire elemnt contributes barystatic
    58215821        IssmDouble I;  //change in ice thickness or water level(Farrel and Clarke, Equ. 4)
    58225822        bool notfullygrounded=false;
    … …  
    58405840        if(!masks->isiceonly[this->lid]){
    58415841                #ifdef _ISSM_DEBUG_
    5842                 constant=0; this->AddInput(SealevelEustaticMaskEnum,&constant,P0Enum);
     5842                constant=0; this->AddInput(SealevelBarystaticMaskEnum,&constant,P0Enum);
    58435843                #endif
    58445844                bslrice=0;
    … …  
    58505850                constant=0;
    58515851                #ifdef _ISSM_DEBUG_
    5852                 this->AddInput(SealevelEustaticMaskEnum,&constant,P0Enum);
     5852                this->AddInput(SealevelBarystaticMaskEnum,&constant,P0Enum);
    58535853                #endif
    58545854                bslrice=0;
    … …  
    58625862        constant=1;
    58635863        #ifdef _ISSM_DEBUG_
    5864         this->AddInput(SealevelEustaticMaskEnum,&constant,P0Enum);
     5864        this->AddInput(SealevelBarystaticMaskEnum,&constant,P0Enum);
    58655865        #endif
    58665866
    … …  
    58735873
    58745874        /*retrieve precomputed G:*/
    5875         if(computerigid)this->inputs->GetArrayPtr(SealevelriseGEnum,this->lid,&G,&gsize);
    5876 
    5877         /*Get area of element: precomputed in the sealevelrise_core_geometry:*/
     5875        if(computerigid)this->inputs->GetArrayPtr(SealevelchangeGEnum,this->lid,&G,&gsize);
     5876
     5877        /*Get area of element: precomputed in the sealevelchange_geometry:*/
    58785878        this->Element::GetInputValue(&area,AreaEnum);
    58795879
    … …  
    58865886                if(glfraction==0)phi=1;
    58875887                #ifdef _ISSM_DEBUG_
    5888                 this->AddInput(SealevelEustaticMaskEnum,&phi,P0Enum);
     5888                this->AddInput(SealevelBarystaticMaskEnum,&phi,P0Enum);
    58895889                #endif
    58905890        }
    … …  
    58935893        /*Retrieve ice thickness at vertices: */
    58945894        Input* deltathickness_input=this->GetInput(SurfaceloadIceThicknessChangeEnum);
    5895         if (!deltathickness_input)_error_("delta thickness input needed to compute sea level rise!");
     5895        if (!deltathickness_input)_error_("delta thickness input needed to compute sea level change!");
    58965896
    58975897        /*/Average ice thickness over grounded area of the element only: {{{*/
    … …  
    59445944}
    59455945/*}}}*/
    5946 IssmDouble Tria::SealevelriseEustaticHydro(IssmDouble* Sgi, SealevelMasks* masks, Vector<IssmDouble>* barystatic_contribution, IssmDouble* partition, IssmDouble oceanarea){ /*{{{*/
     5946IssmDouble Tria::SealevelchangeBarystaticHydro(IssmDouble* Sgi, SealevelMasks* masks, Vector<IssmDouble>* barystatic_contribution, IssmDouble* partition, IssmDouble oceanarea){ /*{{{*/
    59475947
    59485948        /*diverse:*/
    … …  
    59875987
    59885988        /*retrieve precomputed G:*/
    5989         if(computeelastic)this->inputs->GetArrayPtr(SealevelriseGEnum,this->lid,&G,&gsize);
    5990 
    5991         /*Get area of element: precomputed in the sealevelrise_core_geometry:*/
     5989        if(computeelastic)this->inputs->GetArrayPtr(SealevelchangeGEnum,this->lid,&G,&gsize);
     5990
     5991        /*Get area of element: precomputed in the sealevelchange_geometry:*/
    59925992        this->Element::GetInputValue(&area,AreaEnum);
    59935993
    59945994        /*Retrieve water height at vertices: */
    59955995        Input* deltathickness_input=this->GetInput(SurfaceloadWaterHeightChangeEnum);
    5996         if (!deltathickness_input)_error_("SurfaceloadWaterHeightChangeEnum input needed to compute sea level rise!");
     5996        if (!deltathickness_input)_error_("SurfaceloadWaterHeightChangeEnum input needed to compute sea level change!");
    59975997        deltathickness_input->GetInputAverage(&W);
    59985998
    … …  
    60206020}
    60216021/*}}}*/
    6022 void    Tria::SealevelriseEustaticBottomPressure(IssmDouble* Sgi,SealevelMasks* masks){ /*{{{*/
     6022void    Tria::SealevelchangeBarystaticBottomPressure(IssmDouble* Sgi,SealevelMasks* masks){ /*{{{*/
    60236023
    60246024        /*diverse:*/
    … …  
    60446044        /*Inform mask: */
    60456045        #ifdef _ISSM_DEBUG_
    6046         constant=1; this->AddInput(SealevelEustaticMaskEnum,&constant,P0Enum);
     6046        constant=1; this->AddInput(SealevelBarystaticMaskEnum,&constant,P0Enum);
    60476047        #endif
    60486048
    … …  
    60516051
    60526052        /*retrieve precomputed G:*/
    6053         this->inputs->GetArrayPtr(SealevelriseGEnum,this->lid,&G,&gsize);
    6054 
    6055         /*Get area of element: precomputed in the sealevelrise_core_geometry:*/
     6053        this->inputs->GetArrayPtr(SealevelchangeGEnum,this->lid,&G,&gsize);
     6054
     6055        /*Get area of element: precomputed in the sealevelchange_geometry:*/
    60566056        this->Element::GetInputValue(&area,AreaEnum);
    60576057
    60586058        /*Retrieve bottom pressure change and average over the element: */
    60596059        Input* bottompressure_change_input=this->GetInput(DslSeaWaterPressureChangeAtSeaFloorEnum);
    6060         if (!bottompressure_change_input)_error_("bottom pressure input needed to compute sea level rise fingerprint!");
     6060        if (!bottompressure_change_input)_error_("bottom pressure input needed to compute sea level change fingerprint!");
    60616061        bottompressure_change_input->GetInputAverage(&BP);
    60626062
    … …  
    60706070}
    60716071/*}}}*/
    6072 void    Tria::SealevelriseNonEustatic(IssmDouble* Sgo,IssmDouble* Sg_old, SealevelMasks* masks){ /*{{{*/
     6072void    Tria::SealevelchangeSal(IssmDouble* Sgo,IssmDouble* Sg_old, SealevelMasks* masks){ /*{{{*/
    60736073
    60746074        /*diverse:*/
    … …  
    60886088                constant=0;
    60896089                #ifdef _ISSM_DEBUG_
    6090                 this->AddInput(SealevelEustaticOceanMaskEnum,&constant,P0Enum);
     6090                this->AddInput(SealevelBarystaticOceanMaskEnum,&constant,P0Enum);
    60916091                #endif
    60926092                return;
    … …  
    60946094        constant=1;
    60956095        #ifdef _ISSM_DEBUG_
    6096         this->AddInput(SealevelEustaticOceanMaskEnum,&constant,P0Enum);
     6096        this->AddInput(SealevelBarystaticOceanMaskEnum,&constant,P0Enum);
    60976097        #endif
    60986098
    … …  
    61016101
    61026102        /*retrieve precomputed G:*/
    6103         this->inputs->GetArrayPtr(SealevelriseGEnum,this->lid,&G,&dummy); _assert_(dummy==gsize);
    6104 
    6105         /*From Sg_old, recover water sea level rise:*/
     6103        this->inputs->GetArrayPtr(SealevelchangeGEnum,this->lid,&G,&dummy); _assert_(dummy==gsize);
     6104
     6105        /*From Sg_old, recover water sea level change:*/
    61066106        S=0; for(int i=0;i<NUMVERTICES;i++) S+=Sg_old[this->vertices[i]->Sid()]/NUMVERTICES;
    61076107
    … …  
    61146114}
    61156115/*}}}*/
    6116 void    Tria::SealevelriseGeodetic(IssmDouble* Up, IssmDouble* North ,IssmDouble* East,IssmDouble* Sg, SealevelMasks* masks){ /*{{{*/
     6116void    Tria::DeformationFromSurfaceLoads(IssmDouble* Up, IssmDouble* North ,IssmDouble* East,IssmDouble* Sg, SealevelMasks* masks){ /*{{{*/
    61176117
    61186118        /*diverse:*/
    … …  
    61476147
    61486148        /*recover elastic Green's functions for displacement:*/
    6149         this->inputs->GetArrayPtr(SealevelriseGUEnum,this->lid,&GU,&gsize);
     6149        this->inputs->GetArrayPtr(SealevelchangeGUEnum,this->lid,&GU,&gsize);
    61506150        if(horiz){
    6151                 this->inputs->GetArrayPtr(SealevelriseGEEnum,this->lid,&GE,&gsize);
    6152                 this->inputs->GetArrayPtr(SealevelriseGNEnum,this->lid,&GN,&gsize);
     6151                this->inputs->GetArrayPtr(SealevelchangeGEEnum,this->lid,&GE,&gsize);
     6152                this->inputs->GetArrayPtr(SealevelchangeGNEnum,this->lid,&GN,&gsize);
    61536153        }
    61546154
    61556155
    61566156        if(masks->isoceanin[this->lid]){
    6157                 /*From Sg, recover water sea level rise:*/
     6157                /*From Sg, recover water sea level change:*/
    61586158                S=0; for(int i=0;i<NUMVERTICES;i++) S+=Sg[this->vertices[i]->Sid()]/NUMVERTICES;
    61596159
    … …  
    61646164                if(bp_compute_fingerprints){
    61656165                        Input* bottompressure_change_input=this->GetInput(DslSeaWaterPressureChangeAtSeaFloorEnum);
    6166                         if (!bottompressure_change_input)_error_("bottom pressure input needed to compute sea level rise fingerprint!");
     6166                        if (!bottompressure_change_input)_error_("bottom pressure input needed to compute sea level change fingerprint!");
    61676167                        bottompressure_change_input->GetInputAverage(&BP);
    61686168
    … …  
    61856185                /*Compute ice thickness change: */
    61866186                Input* deltathickness_input=this->GetInput(SurfaceloadIceThicknessChangeEnum);
    6187                 if (!deltathickness_input)_error_("delta thickness input needed to compute sea level rise!");
     6187                if (!deltathickness_input)_error_("delta thickness input needed to compute sea level change!");
    61886188                deltathickness_input->GetInputAverage(&I);
    61896189

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

    r25839 r25947  
    162162                #ifdef _HAVE_SEALEVELRISE_
    163163                IssmDouble OceanAverage(IssmDouble* Sg, SealevelMasks* masks);
    164                 void    SealevelriseMomentOfInertia(IssmDouble* dI_list,IssmDouble* Sg_old,SealevelMasks* masks);
     164                void    SealevelchangeMomentOfInertia(IssmDouble* dI_list,IssmDouble* Sg_old,SealevelMasks* masks);
    165165                void    SetSealevelMasks(SealevelMasks* masks);
    166                 void    SealevelriseGeometry(IssmDouble* latitude,IssmDouble* longitude,IssmDouble* radius, IssmDouble* xx, IssmDouble* yy, IssmDouble* zz);
    167                 IssmDouble    SealevelriseEustaticIce(IssmDouble* Sgi, SealevelMasks* masks, Vector<IssmDouble>* barystatic_contribution, IssmDouble* partition, IssmDouble oceanarea);
    168                 IssmDouble    SealevelriseEustaticHydro(IssmDouble* Sgi, SealevelMasks* masks, Vector<IssmDouble>* barystatic_contribution, IssmDouble* partition,IssmDouble oceanarea);
    169                 void    SealevelriseEustaticBottomPressure(IssmDouble* Sgi,SealevelMasks* masks);
    170                 void    SealevelriseNonEustatic(IssmDouble* Sgo,IssmDouble* Sg_old,SealevelMasks* masks);
    171                 void    SealevelriseGeodetic(IssmDouble* Up, IssmDouble* North, IssmDouble* East, IssmDouble* Sg,SealevelMasks* masks);
     166                void    SealevelchangeGeometry(IssmDouble* latitude,IssmDouble* longitude,IssmDouble* radius, IssmDouble* xx, IssmDouble* yy, IssmDouble* zz);
     167                IssmDouble    SealevelchangeBarystaticIce(IssmDouble* Sgi, SealevelMasks* masks, Vector<IssmDouble>* barystatic_contribution, IssmDouble* partition, IssmDouble oceanarea);
     168                IssmDouble    SealevelchangeBarystaticHydro(IssmDouble* Sgi, SealevelMasks* masks, Vector<IssmDouble>* barystatic_contribution, IssmDouble* partition,IssmDouble oceanarea);
     169                void    SealevelchangeBarystaticBottomPressure(IssmDouble* Sgi,SealevelMasks* masks);
     170                void    SealevelchangeSal(IssmDouble* Sgo,IssmDouble* Sg_old,SealevelMasks* masks);
     171                void    DeformationFromSurfaceLoads(IssmDouble* Up, IssmDouble* North, IssmDouble* East, IssmDouble* Sg,SealevelMasks* masks);
    172172                #endif
    173173                /*}}}*/

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

    r25827 r25947  
    833833                        break;
    834834
    835                 case SealevelriseSolutionEnum:
    836                         analyses_temp[numanalyses++]=SealevelriseAnalysisEnum;
     835                case SealevelchangeSolutionEnum:
     836                        analyses_temp[numanalyses++]=SealevelchangeAnalysisEnum;
    837837                        analyses_temp[numanalyses++]=GiaAnalysisEnum;
    838838                        break;
    … …  
    899899                        if(isslr){
    900900                                analyses_temp[numanalyses++]=GiaAnalysisEnum;
    901                                 analyses_temp[numanalyses++]=SealevelriseAnalysisEnum;
     901                                analyses_temp[numanalyses++]=SealevelchangeAnalysisEnum;
    902902                        }
    903903                        if(isesa){
    … …  
    47574757#endif
    47584758#ifdef _HAVE_SEALEVELRISE_
    4759 void FemModel::SealevelriseEustatic(Vector<IssmDouble>* pRSLgi, IssmDouble* poceanarea, IssmDouble* pbslr,IssmDouble* pbslrice, IssmDouble* pbslrhydro, IssmDouble** pbslrice_partition,IssmDouble** pbslrhydro_partition,SealevelMasks* masks) { /*{{{*/
     4759void FemModel::SealevelchangeBarystatic(Vector<IssmDouble>* pRSLgi, IssmDouble* poceanarea, IssmDouble* pbslr,IssmDouble* pbslrice, IssmDouble* pbslrhydro, IssmDouble** pbslrice_partition,IssmDouble** pbslrhydro_partition,SealevelMasks* masks) { /*{{{*/
    47604760
    47614761        /*serialized vectors:*/
    … …  
    47804780               
    47814781
    4782    /*Initialize temporary vector that will be used to sum eustatic components
     4782   /*Initialize temporary vector that will be used to sum barystatic components
    47834783    * on all local elements, prior to assembly:*/
    47844784        int gsize = this->nodes->NumberOfDofs(GsetEnum);
    … …  
    47874787   for(int i=0;i<gsize;i++) indices[i]=i;
    47884788
    4789         /*First, figure out the area of the ocean, which is needed to compute the eustatic component: */
     4789        /*First, figure out the area of the ocean, which is needed to compute the barystatic component: */
    47904790        int i = -1;
    47914791        for(Object* & object : this->elements->objects){
    … …  
    48134813
    48144814
    4815         /*Call the sea level rise core for ice : */
     4815        /*Call the barystatic sea level change core for ice : */
    48164816        bslrice_cpu=0;
    48174817        for(Object* & object : this->elements->objects){
    48184818                Element* element = xDynamicCast<Element*>(object);
    4819                 bslrice_cpu+=element->SealevelriseEustaticIce(RSLgi,masks, bslrice_partition,partitionice,oceanarea);
    4820         }
    4821 
    4822         /*Call the sea level rise core for hydro: */
     4819                bslrice_cpu+=element->SealevelchangeBarystaticIce(RSLgi,masks, bslrice_partition,partitionice,oceanarea);
     4820        }
     4821
     4822        /*Call the barystatic sea level change core for hydro: */
    48234823        bslrhydro_cpu=0;
    48244824        for(int i=0;i<elements->Size();i++){
    48254825                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    4826                 bslrhydro_cpu+=element->SealevelriseEustaticHydro(RSLgi,masks, bslrhydro_partition,partitionhydro,oceanarea);
    4827         }
    4828 
    4829         /*Call the sea level rise core for bottom pressures: */
     4826                bslrhydro_cpu+=element->SealevelchangeBarystaticHydro(RSLgi,masks, bslrhydro_partition,partitionhydro,oceanarea);
     4827        }
     4828
     4829        /*Call the barystatic sea level change core for bottom pressures: */
    48304830        this->parameters->FindParam(&bp_compute_fingerprints,DslComputeFingerprintsEnum);
    48314831        if(bp_compute_fingerprints){
    48324832                for(int i=0;i<elements->Size();i++){
    48334833                        Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    4834                         element->SealevelriseEustaticBottomPressure(RSLgi,masks);
     4834                        element->SealevelchangeBarystaticBottomPressure(RSLgi,masks);
    48354835                }
    48364836        }
    … …  
    48404840        pRSLgi->Assemble();
    48414841
    4842         /*Sum all eustatic components from all cpus:*/
     4842        /*Sum all barystatic components from all cpus:*/
    48434843        ISSM_MPI_Reduce (&bslrice_cpu,&bslrice,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() );
    48444844        ISSM_MPI_Bcast(&bslrice,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
    … …  
    48784878}
    48794879/*}}}*/
    4880 void FemModel::SealevelriseNonEustatic(Vector<IssmDouble>* pRSLgo, Vector<IssmDouble>* pRSLg_old,  SealevelMasks* masks, bool verboseconvolution){/*{{{*/
     4880void FemModel::SealevelchangeSal(Vector<IssmDouble>* pRSLgo, Vector<IssmDouble>* pRSLg_old,  SealevelMasks* masks, bool verboseconvolution){/*{{{*/
    48814881
    48824882        /*serialized vectors:*/
    … …  
    48934893        this->parameters->FindParam(&computerigid,SolidearthSettingsRigidEnum);
    48944894
    4895         /*Initialize temporary vector that will be used to sum eustatic components on all local elements, prior
     4895        /*Initialize temporary vector that will be used to sum barystatic components on all local elements, prior
    48964896         * to assembly:*/
    48974897        gsize = this->nodes->NumberOfDofs(GsetEnum);
    … …  
    49024902        RSLg_old=pRSLg_old->ToMPISerial();
    49034903
    4904         /*Call the sea level rise non-eustatic core only if required: */
     4904        /*Call the sal sea level change core only if required: */
    49054905        if(computerigid){
    49064906                for(Object* & object : this->elements->objects){
    49074907                        Element* element = xDynamicCast<Element*>(object);
    4908                         element->SealevelriseNonEustatic(RSLgo,RSLg_old,masks);
     4908                        element->SealevelchangeSal(RSLgo,RSLg_old,masks);
    49094909                }
    49104910        }
    … …  
    49194919}
    49204920/*}}}*/
    4921 void FemModel::SealevelriseRotationalFeedback(Vector<IssmDouble>* pRSLgo_rot, Vector<IssmDouble>* pRSLg_old, IssmDouble* pIxz, IssmDouble* pIyz, IssmDouble* pIzz,  SealevelMasks* masks){/*{{{*/
     4921void FemModel::SealevelchangeRotationalFeedback(Vector<IssmDouble>* pRSLgo_rot, Vector<IssmDouble>* pRSLg_old, IssmDouble* pIxz, IssmDouble* pIyz, IssmDouble* pIzz,  SealevelMasks* masks){/*{{{*/
    49224922
    49234923        /*serialized vectors:*/
    … …  
    49424942        for(Object* & object : this->elements->objects){
    49434943                Element* element = xDynamicCast<Element*>(object);
    4944                 element->SealevelriseMomentOfInertia(&moi_list[0],RSLg_old,masks );
     4944                element->SealevelchangeMomentOfInertia(&moi_list[0],RSLg_old,masks );
    49454945                moi_list_cpu[0] += moi_list[0];
    49464946                moi_list_cpu[1] += moi_list[1];
    … …  
    50135013}
    50145014/*}}}*/
    5015 void FemModel::SealevelriseElastic(Vector<IssmDouble>* pUp, Vector<IssmDouble>* pNorth, Vector<IssmDouble>* pEast, Vector<IssmDouble>* pRSLg, SealevelMasks* masks){/*{{{*/
     5015void FemModel::SealevelchangeDeformation(Vector<IssmDouble>* pgeoid, Vector<IssmDouble>* pUp, Vector<IssmDouble>* pNorth, Vector<IssmDouble>* pEast, Vector<IssmDouble>* pRSLg, SealevelMasks* masks){/*{{{*/
    50165016
    50175017        /*serialized vectors:*/
    … …  
    50315031        RSLg=pRSLg->ToMPISerial();
    50325032
    5033         /*Initialize temporary vector that will be used to sum eustatic components on all local elements, prior
     5033        /*Initialize temporary vector that will be used to sum barystatic components on all local elements, prior
    50345034         * to assembly:*/
    50355035        gsize = this->nodes->NumberOfDofs(GsetEnum);
    … …  
    50415041        indices=xNew<int>(gsize); for (int i=0;i<gsize;i++)indices[i]=i;
    50425042
    5043         /*Call the sea level rise core: */
     5043        /*Call the deformation from loading routines:*/
    50445044        for(Object* & object : this->elements->objects){
    50455045                Element* element = xDynamicCast<Element*>(object);
    5046                 element->SealevelriseGeodetic(Up,North,East,RSLg,masks);
     5046                element->DeformationFromSurfaceLoads(Up,North,East,RSLg,masks);
    50475047        }
    50485048
    50495049        pUp->SetValues(gsize,indices,Up,ADD_VAL);
    50505050        pUp->Assemble();
     5051       
     5052
     5053        /*Add RSL to Up to find the geoid: */
     5054        pUp->Copy(pgeoid); pgeoid->AXPY(pRSLg,1);
     5055
    50515056        if (horiz){
    50525057                pNorth->SetValues(gsize,indices,North,ADD_VAL);
    … …  
    50665071}
    50675072/*}}}*/
    5068 IssmDouble FemModel::SealevelriseOceanAverage(Vector<IssmDouble>* RSLg,SealevelMasks* masks, IssmDouble oceanarea) { /*{{{*/
     5073IssmDouble FemModel::SealevelchangeOceanAverage(Vector<IssmDouble>* RSLg,SealevelMasks* masks, IssmDouble oceanarea) { /*{{{*/
    50695074
    50705075        IssmDouble* RSLg_serial=NULL;

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

    r25752 r25947  
    166166                #endif
    167167                #ifdef _HAVE_SEALEVELRISE_
    168                 void SealevelriseEustatic(Vector<IssmDouble>* pRSLgi, IssmDouble* poceanarea, IssmDouble* pbslr,IssmDouble* pbslrice, IssmDouble* pbslrhydro, IssmDouble** pbslrice_partition,IssmDouble** pbslrhydro_partition, SealevelMasks* masks);
    169                 void SealevelriseNonEustatic(Vector<IssmDouble>* pSgo, Vector<IssmDouble>* pSg_old,  SealevelMasks* masks,bool verboseconvolution);
    170                 void SealevelriseRotationalFeedback(Vector<IssmDouble>* pRSLgo_rot, Vector<IssmDouble>* pRSLg_old, IssmDouble* pIxz, IssmDouble* pIyz, IssmDouble* pIzz, SealevelMasks* masks);
    171                 void SealevelriseElastic(Vector<IssmDouble>* pUp, Vector<IssmDouble>* pNorth, Vector<IssmDouble>* pEast, Vector<IssmDouble>* pSg_old, SealevelMasks* masks);
    172                 IssmDouble SealevelriseOceanAverage(Vector<IssmDouble>* Sg,SealevelMasks* masks, IssmDouble oceanarea);
     168                void SealevelchangeBarystatic(Vector<IssmDouble>* pRSLgi, IssmDouble* poceanarea, IssmDouble* pbslr,IssmDouble* pbslrice, IssmDouble* pbslrhydro, IssmDouble** pbslrice_partition,IssmDouble** pbslrhydro_partition, SealevelMasks* masks);
     169                void SealevelchangeSal(Vector<IssmDouble>* pSgo, Vector<IssmDouble>* pSg_old,  SealevelMasks* masks,bool verboseconvolution);
     170                void SealevelchangeRotationalFeedback(Vector<IssmDouble>* pRSLgo_rot, Vector<IssmDouble>* pRSLg_old, IssmDouble* pIxz, IssmDouble* pIyz, IssmDouble* pIzz, SealevelMasks* masks);
     171                void SealevelchangeDeformation(Vector<IssmDouble>* pgeoid,Vector<IssmDouble>* pUp, Vector<IssmDouble>* pNorth, Vector<IssmDouble>* pEast, Vector<IssmDouble>* pSg_old, SealevelMasks* masks);
     172                IssmDouble SealevelchangeOceanAverage(Vector<IssmDouble>* Sg,SealevelMasks* masks, IssmDouble oceanarea);
    173173                #endif
    174174                void HydrologyEPLupdateDomainx(IssmDouble* pEplcount);

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

    r25066 r25947  
    5959                        solutioncore=&masstransport_core;
    6060                        break;
    61                 case SealevelriseSolutionEnum:
     61                case SealevelchangeSolutionEnum:
    6262                        solutioncore=&sealevelchange_core;
    6363                        break;

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

    r25627 r25947  
    5454void bmb_core(FemModel* femmodel);
    5555void damage_core(FemModel* femmodel);
     56
     57/*sealevel change cores:*/
    5658void sealevelchange_core(FemModel* femmodel);
    5759void grd_core(FemModel* femmodel);
     60void solidearthexternal_core(FemModel* femmodel);
    5861void dynstr_core(FemModel* femmodel);
    59 void sealevelrise_core_geometry(FemModel* femmodel);
    60 SealevelMasks* sealevelrise_core_masks(FemModel* femmodel);
    61 Vector<IssmDouble>* sealevelrise_core_eustatic(FemModel* femmodel,SealevelMasks* mask, IssmDouble* poceanarea);
    62 Vector<IssmDouble>* sealevelrise_core_noneustatic(FemModel* femmodel,SealevelMasks* masks, Vector<IssmDouble>* RSLg_eustatic,IssmDouble oceanarea);
    63 void sealevelrise_core_elastic(Vector<IssmDouble>** pU_radial, Vector<IssmDouble>** pU_north,Vector<IssmDouble>** pU_east,FemModel* femmodel,Vector<IssmDouble>* RSLg, SealevelMasks* masks);
    64 void sealevelrise_core_viscous(Vector<IssmDouble>** pU_gia,Vector<IssmDouble>** pN_gia,FemModel*  femmodel,Vector<IssmDouble>* RSLg);
    65 void sealevelrise_diagnostics(FemModel* femmodel,Vector<IssmDouble>* RSLg);
    66 IssmDouble objectivefunction(IssmDouble search_scalar,FemModel* femmodel);
     62void sealevelchange_geometry(FemModel* femmodel);
     63SealevelMasks* sealevel_masks(FemModel* femmodel);
     64Vector<IssmDouble>* sealevelchange_core_barystatic(FemModel* femmodel,SealevelMasks* mask, IssmDouble* poceanarea);
     65Vector<IssmDouble>* sealevelchange_core_sal(FemModel* femmodel,SealevelMasks* masks, Vector<IssmDouble>* RSLg_barystatic,IssmDouble oceanarea);
     66void sealevelchange_core_deformation(Vector<IssmDouble>** pN_radial, Vector<IssmDouble>** pU_radial, Vector<IssmDouble>** pU_north,Vector<IssmDouble>** pU_east,FemModel* femmodel,Vector<IssmDouble>* RSLg, SealevelMasks* masks);
    6767void GetStericRate(Vector<IssmDouble> ** psteric_rate_g, FemModel* femmodel);
    6868void GetDynamicRate(Vector<IssmDouble> ** pdynamic_rate_g, FemModel* femmodel);
    … …  
    7171//optimization
    7272int GradJSearch(IssmDouble* search_vector,FemModel* femmodel,int step);
     73IssmDouble objectivefunction(IssmDouble search_scalar,FemModel* femmodel);
    7374
    7475//diverse

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

    r25680 r25947  
    6464                InputDuplicatex(femmodel,BaseEnum,BaseOldEnum);
    6565                InputDuplicatex(femmodel,SurfaceEnum,SurfaceOldEnum);
    66                 InputDuplicatex(femmodel,SealevelriseCumDeltathicknessEnum,SealevelriseCumDeltathicknessOldEnum);
     66                InputDuplicatex(femmodel,SealevelchangeCumDeltathicknessEnum,SealevelchangeCumDeltathicknessOldEnum);
    6767                if(stabilization==4){
    6868                        solutionsequence_fct(femmodel);

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

    r25827 r25947  
    2525        bool isgia=0;
    2626        int  grd=0;
     27        int  isexternal=0;
     28        int  iscoupler=0;
    2729        int solution_type;
    2830
    … …  
    3234        femmodel->parameters->FindParam(&save_results,SaveResultsEnum);
    3335        femmodel->parameters->FindParam(&grd,SolidearthSettingsGRDEnum);
    34 
    35         /*in case we are running SealevelriseSolutionEnum, then bypass transient settings:*/
    36         if(solution_type==SealevelriseSolutionEnum){
     36        femmodel->parameters->FindParam(&isexternal,SolidearthIsExternalEnum);
     37        femmodel->parameters->FindParam(&iscoupler,TransientIscouplerEnum);
     38
     39        /*in case we are running SealevelchangeSolutionEnum, then bypass transient settings:*/
     40        if(solution_type==SealevelchangeSolutionEnum){
    3741                isslr=1;
    3842                isgia=1;
    … …  
    4347
    4448        /*Verbose: */
    45         if(VerboseSolution()) _printf0_("   computing sea level rise\n");
     49        if(VerboseSolution()) _printf0_("   computing sea level change\n");
    4650
    4751        /*Run gia core: */
    … …  
    5559
    5660        /*set SLR configuration: */
    57         femmodel->SetCurrentConfiguration(SealevelriseAnalysisEnum);
     61        femmodel->SetCurrentConfiguration(SealevelchangeAnalysisEnum);
    5862
    5963        /*run geometry core: */
    60         sealevelrise_core_geometry(femmodel);
     64        sealevelchange_geometry(femmodel);
     65
     66        /*any external forcings?:*/
     67        if(isexternal)solidearthexternal_core(femmodel);
    6168
    6269        /*Run geodetic:*/
     70        //if(modelid==earthid)  //not sure how we proceed yet on coupling.
    6371        if(grd)grd_core(femmodel);
    6472
    6573        /*Run steric core for sure:*/
    6674        dynstr_core(femmodel);
     75
     76        if(iscoupler){
     77                /*transfer sea level back to ice caps:*/
     78                TransferSealevel(femmodel,SealevelEnum);
     79                TransferSealevel(femmodel,BedEnum);
     80
     81                //reset cumdeltathickness  to 0:
     82                InputUpdateFromConstantx(femmodel->inputs,femmodel->elements,0.,SealevelchangeCumDeltathicknessEnum);
     83        }
    6784
    6885        /*Save results: */
    … …  
    7188                char **requested_outputs = NULL;
    7289                if(VerboseSolution()) _printf0_("   saving results\n");
    73                 femmodel->parameters->FindParam(&requested_outputs,&numoutputs,SealevelriseRequestedOutputsEnum);
     90                femmodel->parameters->FindParam(&requested_outputs,&numoutputs,SealevelchangeRequestedOutputsEnum);
    7491                femmodel->RequestedOutputsx(&femmodel->results,requested_outputs,numoutputs);
    7592                if(numoutputs){for(int i=0;i<numoutputs;i++){xDelete<char>(requested_outputs[i]);} xDelete<char*>(requested_outputs);}
    … …  
    7794
    7895        /*requested dependents: */
    79         if(solution_type==SealevelriseSolutionEnum)femmodel->RequestedDependentsx();
     96        if(solution_type==SealevelchangeSolutionEnum)femmodel->RequestedDependentsx();
    8097       
    8198        /*End profiler*/
    … …  
    83100}
    84101/*}}}*/
     102void solidearthexternal_core(FemModel* femmodel){ /*{{{*/
     103
     104        /*variables:*/
     105        Vector<IssmDouble> *bedrock  = NULL;
     106        Vector<IssmDouble> *bedrock_rate = NULL;
     107        Vector<IssmDouble> *bedrockeast  = NULL;
     108        Vector<IssmDouble> *bedrockeast_rate = NULL;
     109        Vector<IssmDouble> *bedrocknorth  = NULL;
     110        Vector<IssmDouble> *bedrocknorth_rate = NULL;
     111        Vector<IssmDouble> *geoid= NULL;
     112        Vector<IssmDouble> *geoid_rate= NULL;
     113        int horiz=0;
     114        int modelid=-1;
     115   
     116        /*parameters: */
     117        bool isslr=0;
     118        int  solution_type;
     119        IssmDouble          dt;
     120
     121        /*Retrieve parameters:*/
     122        femmodel->parameters->FindParam(&isslr,TransientIsslrEnum);
     123        femmodel->parameters->FindParam(&horiz,SolidearthSettingsHorizEnum);
     124        femmodel->parameters->FindParam(&dt,TimesteppingTimeStepEnum);
     125        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
     126
     127        /*in case we are running SealevelchangeSolutionEnum, then bypass transient settings:*/
     128        if(solution_type==SealevelchangeSolutionEnum)isslr=1;
     129
     130        /*Should we be here?:*/
     131        if(!isslr)return;
     132
     133        /*Verbose: */
     134        if(VerboseSolution()) _printf0_("         computing external solid earth contributions\n");
     135
     136        /*Retrieve geoid viscous and elastic rates, bedrock uplift viscous and elastic rates + steric rate, as vectors:*/
     137        GetVectorFromInputsx(&bedrock,femmodel,BedEnum,VertexSIdEnum);
     138        GetVectorFromInputsx(&geoid,femmodel,SealevelEnum,VertexSIdEnum); //In ISSM, Sealevel is absolute.
     139        if(horiz){
     140                GetVectorFromInputsx(&bedrockeast,femmodel,BedEastEnum,VertexSIdEnum);
     141                GetVectorFromInputsx(&bedrocknorth,femmodel,BedNorthEnum,VertexSIdEnum);
     142        }
     143        /*Deal with Mme: */
     144        if (femmodel->inputs->GetInputObjectEnum(SolidearthExternalDisplacementEastRateEnum)==DatasetInputEnum){
     145                /*retrieve model id: */
     146                femmodel->parameters->FindParam(&modelid,SolidearthExternalModelidEnum);
     147                /*replace dataset of forcings with only one, the modelid'th:*/
     148                MmeToInputFromId(femmodel,modelid,SolidearthExternalDisplacementNorthRateEnum, P1Enum);
     149                MmeToInputFromId(femmodel,modelid,SolidearthExternalDisplacementEastRateEnum, P1Enum);
     150                MmeToInputFromId(femmodel,modelid,SolidearthExternalDisplacementUpRateEnum, P1Enum);
     151                MmeToInputFromId(femmodel,modelid,SolidearthExternalGeoidRateEnum, P1Enum);
     152                MmeToInputFromId(femmodel,modelid,SolidearthExternalBarystaticSeaLevelRateEnum, P1Enum);
     153        }
     154       
     155        GetVectorFromInputsx(&geoid_rate,femmodel,SolidearthExternalGeoidRateEnum,VertexSIdEnum);
     156        GetVectorFromInputsx(&bedrock_rate,femmodel,SolidearthExternalDisplacementUpRateEnum,VertexSIdEnum);
     157        if(horiz){
     158                GetVectorFromInputsx(&bedrockeast_rate,femmodel,SolidearthExternalDisplacementEastRateEnum,VertexSIdEnum);
     159                GetVectorFromInputsx(&bedrocknorth_rate,femmodel,SolidearthExternalDisplacementNorthRateEnum,VertexSIdEnum);
     160        }
     161
     162        /*compute: sea level change = initial sea level + (N_gia_rate+N_esa_rate)  * dt + steric_rate + dynamic_rate dt*/
     163        geoid->AXPY(geoid_rate,dt);
     164        bedrock->AXPY(bedrock_rate,dt);
     165        if(horiz){
     166                bedrockeast->AXPY(bedrockeast_rate,dt);
     167                bedrocknorth->AXPY(bedrocknorth_rate,dt);
     168        }
     169
     170        /*update element inputs:*/
     171        InputUpdateFromVectorx(femmodel,bedrock,BedEnum,VertexSIdEnum);
     172        InputUpdateFromVectorx(femmodel,geoid,SealevelEnum,VertexSIdEnum);     
     173        if(horiz){
     174                InputUpdateFromVectorx(femmodel,bedrockeast,BedEastEnum,VertexSIdEnum);
     175                InputUpdateFromVectorx(femmodel,bedrocknorth,BedNorthEnum,VertexSIdEnum);       
     176        }
     177
     178        /*Free ressources:*/   
     179        delete bedrock; delete bedrock_rate;
     180        delete geoid; delete geoid_rate;
     181        if(horiz){
     182                delete bedrockeast; delete bedrockeast_rate;
     183                delete bedrocknorth; delete bedrocknorth_rate;
     184        }
     185}
     186/*}}}*/
    85187void grd_core(FemModel* femmodel){ /*{{{*/
    86188
    … …  
    89191        /*variables:*/
    90192        Vector<IssmDouble> *RSLg    = NULL;
    91         Vector<IssmDouble> *BPg    = NULL;
    92         Vector<IssmDouble> *RSLg_rate    = NULL;
    93         Vector<IssmDouble> *RSLg_eustatic  = NULL;
    94         Vector<IssmDouble> *U_esa  = NULL;
    95         Vector<IssmDouble> *U_esa_rate  = NULL;
    96         Vector<IssmDouble> *N_esa  = NULL;
    97         Vector<IssmDouble> *N_esa_rate  = NULL;
    98         Vector<IssmDouble> *U_north_esa   = NULL;
    99         Vector<IssmDouble> *U_east_esa    = NULL;
    100         Vector<IssmDouble> *N_gia= NULL;
    101         Vector<IssmDouble> *U_gia= NULL;
    102         Vector<IssmDouble> *N_gia_rate= NULL;
    103         Vector<IssmDouble> *U_gia_rate= NULL;
     193        Vector<IssmDouble> *RSLg_barystatic  = NULL;
     194        Vector<IssmDouble> *U_grd  = NULL;
     195        Vector<IssmDouble> *N_grd  = NULL;
     196        Vector<IssmDouble> *U_north_grd   = NULL;
     197        Vector<IssmDouble> *U_east_grd    = NULL;
     198        Vector<IssmDouble> *bedrock  = NULL;
     199        Vector<IssmDouble> *bedrockeast  = NULL;
     200        Vector<IssmDouble> *bedrocknorth  = NULL;
     201        Vector<IssmDouble> *geoid= NULL;
    104202        SealevelMasks* masks=NULL;
    105203
    … …  
    113211        IssmDouble dt;
    114212        IssmDouble oceanarea;
    115         int        bp_compute_fingerprints=0;
    116 
    117        
     213        int bp_compute_fingerprints=0;
     214
    118215        /*Verbose: */
    119216        if(VerboseSolution()) _printf0_("         computing GRD sea level patterns\n");
    … …  
    122219        femmodel->parameters->FindParam(&iscoupler,TransientIscouplerEnum);
    123220        femmodel->parameters->FindParam(&frequency,SolidearthSettingsRunFrequencyEnum);
    124         femmodel->parameters->FindParam(&count,SealevelriseRunCountEnum);
     221        femmodel->parameters->FindParam(&count,SealevelchangeRunCountEnum);
    125222        femmodel->parameters->FindParam(&horiz,SolidearthSettingsHorizEnum);
    126223        femmodel->parameters->FindParam(&dt,TimesteppingTimeStepEnum);
    … …  
    136233                 * so make sure we are identified as being the Earth.:*/
    137234                modelid=1; earthid=1;
    138                 /* in addition, if we are running solution_type SealevelriseSolutionEnum, make sure we
     235                /* in addition, if we are running solution_type SealevelchangeSolutionEnum, make sure we
    139236                 * run, irresepective of the time settings:*/
    140237                count=frequency;
    … …  
    148245        /*increment counter, or call solution core if count==frequency:*/
    149246        if (count<frequency){
    150                 count++; femmodel->parameters->SetParam(count,SealevelriseRunCountEnum);
     247                count++; femmodel->parameters->SetParam(count,SealevelchangeRunCountEnum);
    151248                return;
    152249        }
    153250
    154         /*call sea-level rise sub cores:*/
     251        /*call sea-level change sub cores:*/
    155252        if(iscoupler){
    156253                /*transfer cumulated deltathickness forcing from ice caps to earth model: */
    157                 TransferForcing(femmodel,SealevelriseCumDeltathicknessEnum);
     254                TransferForcing(femmodel,SealevelchangeCumDeltathicknessEnum);
    158255
    159256                /*we have accumulated thicknesses, dump them in deltathcikness: */
    160                 if(modelid==earthid)InputDuplicatex(femmodel,SealevelriseCumDeltathicknessEnum,SurfaceloadIceThicknessChangeEnum);
     257                if(modelid==earthid)InputDuplicatex(femmodel,SealevelchangeCumDeltathicknessEnum,SurfaceloadIceThicknessChangeEnum);
    161258        }
    162259
    … …  
    165262
    166263                /*call masks core: */
    167                 masks=sealevelrise_core_masks(femmodel);
     264                masks=sealevel_masks(femmodel);
    168265
    169266                /*set bottom pressures:*/
    170267                SetBottomPressure(femmodel);
    171268
    172 
    173                 /*call eustatic core  (generalized eustatic - Farrel and Clark, Eq 4, 1st, 3rd and 4rd terms on the RHS) */
    174                 RSLg_eustatic=sealevelrise_core_eustatic(femmodel,masks,&oceanarea);
    175 
    176                 /*call non-eustatic core (ocean loading tems  - 2nd and 5th terms on the RHS of Farrel and Clark) */
    177                 RSLg=sealevelrise_core_noneustatic(femmodel,masks,RSLg_eustatic,oceanarea);
    178 
    179                 /*compute other elastic signatures, such as components of 3-D crustal motion: */
    180                 sealevelrise_core_elastic(&U_esa,&U_north_esa,&U_east_esa,femmodel,RSLg,masks);
    181 
    182                 /*compute viscosus (GIA) signatures:*/
    183                 sealevelrise_core_viscous(&U_gia,&N_gia,femmodel,RSLg);
    184 
    185                 /*compute sea-level rise (low-order spherical harmonics coefficients) diagnostics:*/
    186                 sealevelrise_diagnostics(femmodel,RSLg);
    187 
    188                 /*recover N_esa  = U_esa + RSLg:*/
    189                 N_esa=U_esa->Duplicate(); U_esa->Copy(N_esa); N_esa->AXPY(RSLg,1);
    190 
    191                 /*transform these values into rates (as we only run this once each frequency turn:*/
    192                 N_esa_rate=N_esa->Duplicate(); N_esa->Copy(N_esa_rate); N_esa_rate->Scale(1/(dt*frequency));
    193                 U_esa_rate=U_esa->Duplicate(); U_esa->Copy(U_esa_rate); U_esa_rate->Scale(1/(dt*frequency));
    194                 N_gia_rate=N_gia->Duplicate(); N_gia->Copy(N_gia_rate); N_gia_rate->Scale(1/(dt*frequency));
    195                 U_gia_rate=U_gia->Duplicate(); U_gia->Copy(U_gia_rate); U_gia_rate->Scale(1/(dt*frequency));
    196                 RSLg_rate=RSLg->Duplicate(); RSLg->Copy(RSLg_rate); RSLg_rate->Scale(1/(dt*frequency));
    197 
    198                 /*get some results into elements:{{{*/
    199                 InputUpdateFromVectorx(femmodel,U_esa_rate,SealevelUEsaRateEnum,VertexSIdEnum);
    200                 InputUpdateFromVectorx(femmodel,N_esa_rate,SealevelNEsaRateEnum,VertexSIdEnum);
    201                 InputUpdateFromVectorx(femmodel,U_gia_rate,UGiaRateEnum,VertexSIdEnum);
    202                 InputUpdateFromVectorx(femmodel,N_gia_rate,NGiaRateEnum,VertexSIdEnum);
    203                 InputUpdateFromVectorx(femmodel,RSLg_rate,SealevelRSLRateEnum,VertexSIdEnum);
    204                 InputUpdateFromVectorx(femmodel,U_esa,SealevelUEsaEnum,VertexSIdEnum);
    205                 InputUpdateFromVectorx(femmodel,N_esa,SealevelNEsaEnum,VertexSIdEnum);
    206                 InputUpdateFromVectorx(femmodel,U_gia,UGiaEnum,VertexSIdEnum);
    207                 InputUpdateFromVectorx(femmodel,N_gia,NGiaEnum,VertexSIdEnum);
     269                /*call barystatic core  (generalized eustatic - Farrel and Clark, Eq 4, 1st, 3rd and 4rd terms on the RHS) */
     270                RSLg_barystatic=sealevelchange_core_barystatic(femmodel,masks,&oceanarea);
     271
     272                /*call self attraction and loading module (ocean loading tems  - 2nd and 5th terms on the RHS of Farrel and Clark) */
     273                RSLg=sealevelchange_core_sal(femmodel,masks,RSLg_barystatic,oceanarea);
     274
     275                /*compute bedrock motion and derive geoid: */
     276                sealevelchange_core_deformation(&N_grd,&U_grd,&U_north_grd,&U_east_grd,femmodel,RSLg,masks);
     277
     278                /*Update bedrock motion and geoid:*/
     279                GetVectorFromInputsx(&geoid,femmodel,SealevelEnum,VertexSIdEnum);
     280                GetVectorFromInputsx(&bedrock,femmodel,BedEnum,VertexSIdEnum);
     281                if(horiz){
     282                        GetVectorFromInputsx(&bedrockeast,femmodel,BedEastEnum,VertexSIdEnum);
     283                        GetVectorFromInputsx(&bedrocknorth,femmodel,BedNorthEnum,VertexSIdEnum);
     284                }
     285               
     286                geoid->AXPY(N_grd,1);
     287                bedrock->AXPY(U_grd,1);
     288                if(horiz){
     289                        bedrockeast->AXPY(U_east_grd,1);
     290                        bedrocknorth->AXPY(U_north_grd,1);
     291                }
     292
     293                /*get some of the updates into elements:*/
     294                InputUpdateFromVectorx(femmodel,U_grd,SealevelUEsaEnum,VertexSIdEnum);
     295                InputUpdateFromVectorx(femmodel,N_grd,SealevelNEsaEnum,VertexSIdEnum);
    208296                InputUpdateFromVectorx(femmodel,RSLg,SealevelRSLEnum,VertexSIdEnum);
    209                 InputUpdateFromVectorx(femmodel,RSLg_eustatic,SealevelRSLEustaticEnum,VertexSIdEnum);
    210 
     297                InputUpdateFromVectorx(femmodel,RSLg_barystatic,SealevelRSLBarystaticEnum,VertexSIdEnum);
    211298                if (horiz){
    212                         InputUpdateFromVectorx(femmodel,U_north_esa,SealevelUNorthEsaEnum,VertexSIdEnum);       // north motion
    213                         InputUpdateFromVectorx(femmodel,U_east_esa,SealevelUEastEsaEnum,VertexSIdEnum);         // east motion
    214                 } /*}}}*/
    215         }
    216 
    217         if(iscoupler){
    218                 /*transfer sea level back to ice caps:*/
    219                 TransferSealevel(femmodel,SealevelNEsaRateEnum);
    220                 TransferSealevel(femmodel,NGiaRateEnum);
    221                 TransferSealevel(femmodel,SealevelUEsaRateEnum);
    222                 TransferSealevel(femmodel,UGiaRateEnum);
    223 
    224                 //reset cumdeltathickness  to 0:
    225                 InputUpdateFromConstantx(femmodel->inputs,femmodel->elements,0.,SealevelriseCumDeltathicknessEnum);
     299                        InputUpdateFromVectorx(femmodel,U_north_grd,SealevelUNorthEsaEnum,VertexSIdEnum);       
     300                        InputUpdateFromVectorx(femmodel,U_east_grd,SealevelUEastEsaEnum,VertexSIdEnum);
     301                }
    226302        }
    227303
    228304        /*reset counter to 1:*/
    229         femmodel->parameters->SetParam(1,SealevelriseRunCountEnum); //reset counter.
     305        femmodel->parameters->SetParam(1,SealevelchangeRunCountEnum); //reset counter.
    230306
    231307        /*free ressources:{{{*/
    232308        delete RSLg;
    233         delete RSLg_rate;
    234         delete RSLg_eustatic;
    235         delete U_esa;
    236         delete U_esa_rate;
    237         delete N_esa;
    238         delete N_esa_rate;
    239         delete BPg;
    240 
     309        delete RSLg_barystatic;
     310        delete U_grd;
     311        delete N_grd;
     312        delete bedrock;
     313        delete geoid;
    241314        if(horiz){
    242                 delete U_north_esa;
    243                 delete U_east_esa;
    244         }
    245         delete N_gia;
    246         delete U_gia;
    247         delete N_gia_rate;
    248         delete U_gia_rate;
    249         //delete masks;
     315                delete U_north_grd;
     316                delete U_east_grd;
     317                delete bedrockeast;
     318                delete bedrocknorth;
     319        }
     320        delete masks;
    250321        /*}}}*/
    251322
    … …  
    255326
    256327        /*variables:*/
    257         Vector<IssmDouble> *bedrock  = NULL;
    258         Vector<IssmDouble> *SL  = NULL;
     328        Vector<IssmDouble> *sealevel  = NULL;
    259329        Vector<IssmDouble> *steric_rate_g  = NULL;
    260330        Vector<IssmDouble> *dynamic_rate_g = NULL;
    261         Vector<IssmDouble> *U_esa_rate= NULL;
    262         Vector<IssmDouble> *N_esa_rate= NULL;
    263         Vector<IssmDouble> *U_gia_rate= NULL;
    264         Vector<IssmDouble> *N_gia_rate= NULL;
    265331
    266332        /*parameters: */
    … …  
    268334        int  solution_type;
    269335        IssmDouble          dt;
    270         int  grd=0;
    271336        int  step;
    272337        IssmDouble time;
     338
    273339        IssmDouble cumgmtslr=0;
    274340        IssmDouble cumbslr=0;
    … …  
    277343
    278344        /*Retrieve parameters:*/
     345        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    279346        femmodel->parameters->FindParam(&isslr,TransientIsslrEnum);
     347       
     348        /*in case we are running SealevelchangeSolutionEnum, then bypass transient settings:*/
     349        if(solution_type==SealevelchangeSolutionEnum)isslr=1;
     350
     351        /*Should we be here?:*/
     352        if(!isslr)return;
     353
     354        /*Verbose: */
     355        if(VerboseSolution()) _printf0_("         computing steric sea level change\n");
     356
     357        /*Retrieve sealevel and add steric + dynamic rates:*/
     358        GetVectorFromInputsx(&sealevel,femmodel,SealevelEnum,VertexSIdEnum);
     359        GetStericRate(&steric_rate_g,femmodel);
     360        GetDynamicRate(&dynamic_rate_g,femmodel);
     361
     362        /*compute: sea level change = initial sea level + (N_gia_rate+N_esa_rate)  * dt + steric_rate + dynamic_rate dt*/
    280363        femmodel->parameters->FindParam(&dt,TimesteppingTimeStepEnum);
    281         femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    282         femmodel->parameters->FindParam(&grd,SolidearthSettingsGRDEnum);
     364        sealevel->AXPY(steric_rate_g,dt);
     365        sealevel->AXPY(dynamic_rate_g,dt);
     366
     367        /*cumulate thermal steric rate:*/
    283368        femmodel->parameters->FindParam(&cumgmtslr,CumGmtslrEnum);
    284369        femmodel->parameters->FindParam(&cumbslr,CumBslrEnum);
    285         femmodel->parameters->FindParam(&step,StepEnum);
    286         femmodel->parameters->FindParam(&time,TimeEnum);
    287 
    288         /*in case we are running SealevelriseSolutionEnum, then bypass transient settings:*/
    289         if(solution_type==SealevelriseSolutionEnum)isslr=1;
    290 
    291         /*Should we be here?:*/
    292         if(!isslr)return;
    293 
    294         /*Verbose: */
    295         if(VerboseSolution()) _printf0_("         computing steric sea level rise\n");
    296 
    297         /*Retrieve geoid viscous and elastic rates, bedrock uplift viscous and elastic rates + steric rate, as vectors:*/
    298         GetVectorFromInputsx(&bedrock,femmodel,BedEnum,VertexSIdEnum);
    299         GetVectorFromInputsx(&SL,femmodel,SealevelEnum,VertexSIdEnum);
    300         GetStericRate(&steric_rate_g,femmodel);
    301         GetDynamicRate(&dynamic_rate_g,femmodel);
    302         if(grd){
    303                 GetVectorFromInputsx(&U_esa_rate,femmodel,SealevelUEsaRateEnum,VertexSIdEnum);
    304                 GetVectorFromInputsx(&U_gia_rate,femmodel,UGiaRateEnum,VertexSIdEnum);
    305                 GetVectorFromInputsx(&N_esa_rate,femmodel,SealevelNEsaRateEnum,VertexSIdEnum);
    306                 GetVectorFromInputsx(&N_gia_rate,femmodel,NGiaRateEnum,VertexSIdEnum);
    307         }
    308 
    309         /*Save steric rate, and cumulate it through time, cumulate with barystatic sea level rise, and cumulate through time:*/
     370
    310371        gmtslr=steric_rate_g->Max()*dt;
    311372        cumgmtslr+=gmtslr;
    312373        cumgmslr=cumbslr+cumgmtslr;
     374
     375        femmodel->parameters->SetParam(cumgmtslr,CumGmtslrEnum);
     376        femmodel->parameters->SetParam(cumgmslr,CumGmslrEnum);
     377       
     378        /*Outputs some metrics:*/
     379        femmodel->parameters->FindParam(&step,StepEnum);
     380        femmodel->parameters->FindParam(&time,TimeEnum);
     381
    313382        femmodel->results->AddResult(new GenericExternalResult<IssmDouble>(femmodel->results->Size()+1,GmtslrEnum,gmtslr,step,time));
    314383        femmodel->results->AddResult(new GenericExternalResult<IssmDouble>(femmodel->results->Size()+1,CumGmtslrEnum,cumgmtslr,step,time));
    315384        femmodel->results->AddResult(new GenericExternalResult<IssmDouble>(femmodel->results->Size()+1,CumGmslrEnum,cumgmslr,step,time));
    316         femmodel->parameters->SetParam(cumgmtslr,CumGmtslrEnum);
    317 
    318         /*compute: sea level change = initial sea level + (N_gia_rate+N_esa_rate)  * dt + steric_rate + dynamic_rate dt*/
    319         if(grd){
    320                 SL->AXPY(N_gia_rate,dt);
    321                 SL->AXPY(N_esa_rate,dt);
    322         }
    323         SL->AXPY(steric_rate_g,dt);
    324         SL->AXPY(dynamic_rate_g,dt);
    325 
    326         /*compute new bedrock position: */
    327         if(grd){
    328                 bedrock->AXPY(U_esa_rate,dt);
    329                 bedrock->AXPY(U_gia_rate,dt);
    330         }
    331385
    332386        /*update element inputs:*/
    333         InputUpdateFromVectorx(femmodel,bedrock,BedEnum,VertexSIdEnum);
    334         InputUpdateFromVectorx(femmodel,SL,SealevelEnum,VertexSIdEnum);
     387        InputUpdateFromVectorx(femmodel,sealevel,SealevelEnum,VertexSIdEnum);   
    335388
    336389        /*Free ressources:*/   
    337         delete bedrock;
    338         delete SL;
     390        delete sealevel;
    339391        delete steric_rate_g;
    340392        delete dynamic_rate_g;
    341         if(grd){
    342                 delete U_esa_rate;
    343                 delete U_gia_rate;
    344                 delete N_esa_rate;
    345                 delete N_gia_rate;
    346         }
    347393}
    348394/*}}}*/
    349395
    350 SealevelMasks* sealevelrise_core_masks(FemModel* femmodel) {  /*{{{*/
     396//Geometry:
     397SealevelMasks* sealevel_masks(FemModel* femmodel) {  /*{{{*/
    351398
    352399        if(VerboseSolution()) _printf0_("         computing sea level masks\n");
    … …  
    363410        return masks;
    364411}/*}}}*/
    365 void sealevelrise_core_geometry(FemModel* femmodel) {  /*{{{*/
     412void sealevelchange_geometry(FemModel* femmodel) {  /*{{{*/
    366413
    367414        /*Geometry core where we compute indices into tables pre computed in the SealevelRiseAnalysis: */
    … …  
    381428        /*retrieve parameters:*/
    382429        femmodel->parameters->FindParam(&horiz,SolidearthSettingsHorizEnum);
    383         femmodel->parameters->FindParam(&geometrydone,SealevelriseGeometryDoneEnum);
     430        femmodel->parameters->FindParam(&geometrydone,SealevelchangeGeometryDoneEnum);
    384431
    385432        if(geometrydone){
    … …  
    396443
    397444
    398         /*Run sealevelrise geometry routine in elements:*/
     445        /*Run sealevel geometry routine in elements:*/
    399446        for(Object* & object : femmodel->elements->objects){
    400447                Element*   element=xDynamicCast<Element*>(object);
    401                 element->SealevelriseGeometry(latitude,longitude,radius,xx,yy,zz);
     448                element->SealevelchangeGeometry(latitude,longitude,radius,xx,yy,zz);
    402449        }
    403450
    … …  
    413460
    414461        /*Record the fact that we ran this module already: */
    415         femmodel->parameters->SetParam(true,SealevelriseGeometryDoneEnum);
     462        femmodel->parameters->SetParam(true,SealevelchangeGeometryDoneEnum);
    416463
    417464
    418465}/*}}}*/
    419 Vector<IssmDouble>* sealevelrise_core_eustatic(FemModel* femmodel,SealevelMasks* masks, IssmDouble* poceanarea){ /*{{{*/
    420 
    421         /*Eustatic core of the SLR solution (terms that are constant with respect to sea-level)*/
     466
     467//GRD:
     468Vector<IssmDouble>* sealevelchange_core_barystatic(FemModel* femmodel,SealevelMasks* masks, IssmDouble* poceanarea){ /*{{{*/
     469
     470        /*Barystatic core of the SLR solution (terms that are constant with respect to sea-level)*/
    422471
    423472        Vector<IssmDouble> *RSLgi    = NULL;
    … …  
    464513
    465514        /*call the bslr main module: */
    466         femmodel->SealevelriseEustatic(RSLgi,&oceanarea,&bslr, &bslrice, &bslrhydro, &bslrice_partition, &bslrhydro_partition,masks); //this computes
     515        femmodel->SealevelchangeBarystatic(RSLgi,&oceanarea,&bslr, &bslrice, &bslrhydro, &bslrice_partition, &bslrhydro_partition,masks); //this computes
    467516
    468517        /*we need to average RSLgi over the ocean: RHS term  4 in Eq.4 of Farrel and clarke. Only the elements can do that: */
    469         RSLgi_oceanaverage=femmodel->SealevelriseOceanAverage(RSLgi,masks, oceanarea);
     518        RSLgi_oceanaverage=femmodel->SealevelchangeOceanAverage(RSLgi,masks, oceanarea);
    470519
    471520        /*RSLg is the sum of the pure bslr component (term 3) and the contribution from the perturbation to the graviation potential due to the
    … …  
    509558        return RSLgi;
    510559}/*}}}*/
    511 Vector<IssmDouble>* sealevelrise_core_noneustatic(FemModel* femmodel, SealevelMasks* masks, Vector<IssmDouble>* RSLg_eustatic,IssmDouble oceanarea){ /*{{{*/
    512 
    513         /*sealevelrise_core_noneustatic.cpp //this computes the contributions from Eq.4 of Farrel and Clarke, rhs terms 2 and 5.
    514           non eustatic core of the SLR solution */
     560Vector<IssmDouble>* sealevelchange_core_sal(FemModel* femmodel, SealevelMasks* masks, Vector<IssmDouble>* RSLg_barystatic,IssmDouble oceanarea){ /*{{{*/
     561
     562        /*this core computes the contributions from Eq.4 of Farrel and Clarke, rhs terms 2 and 5.
     563          sal core of the SLR solution */
    515564
    516565        Vector<IssmDouble> *RSLg    = NULL;
    … …  
    549598        RSLg = new Vector<IssmDouble>(gsize);
    550599        RSLg->Assemble();
    551         RSLg_eustatic->Copy(RSLg);  //first initialize RSLg with the eustatic component computed in sealevelrise_core_eustatic.
     600        RSLg_barystatic->Copy(RSLg);  //first initialize RSLg with the barystatic component computed in sealevelchange_core_barystatic.
    552601
    553602        RSLg_old = new Vector<IssmDouble>(gsize);
    … …  
    560609        for(;;){
    561610
    562                 //save pointer to old sea level rise
     611                //save pointer to old sea level
    563612                delete RSLg_old; RSLg_old=RSLg;
    564613
    … …  
    567616                RSLgo = new Vector<IssmDouble>(gsize); RSLgo->Assemble();
    568617
    569                 /*call the non eustatic module: */
    570                 femmodel->SealevelriseNonEustatic(RSLgo, RSLg_old,  masks, verboseconvolution);
     618                /*call the sal module: */
     619                femmodel->SealevelchangeSal(RSLgo, RSLg_old,  masks, verboseconvolution);
    571620
    572621                /*assemble solution vector: */
    … …  
    577626                        /*call rotational feedback  module: */
    578627                        RSLgo_rot = new Vector<IssmDouble>(gsize); RSLgo_rot->Assemble();
    579                         femmodel->SealevelriseRotationalFeedback(RSLgo_rot,RSLg_old,&Ixz,&Iyz,&Izz, masks);
     628                        femmodel->SealevelchangeRotationalFeedback(RSLgo_rot,RSLg_old,&Ixz,&Iyz,&Izz, masks);
    580629                        RSLgo_rot->Assemble();
    581630
    … …  
    589638
    590639                /*we need to average RSLgo over the ocean: RHS term  5 in Eq.4 of Farrel and clarke. Only the elements can do that: */
    591                 RSLgo_oceanaverage=femmodel->SealevelriseOceanAverage(RSLgo,masks, oceanarea);
    592 
    593                 /*RSLg is the sum of the eustatic term, and the ocean terms: */
    594                 RSLg_eustatic->Copy(RSLg); RSLg->AXPY(RSLgo,1);
     640                RSLgo_oceanaverage=femmodel->SealevelchangeOceanAverage(RSLgo,masks, oceanarea);
     641
     642                /*RSLg is the sum of the barystatic term, and the ocean terms: */
     643                RSLg_barystatic->Copy(RSLg); RSLg->AXPY(RSLgo,1);
    595644                RSLg->Shift(-RSLgo_oceanaverage);
    596645
    … …  
    625674        return RSLg;
    626675} /*}}}*/
    627 void sealevelrise_core_elastic(Vector<IssmDouble>** pU_esa, Vector<IssmDouble>** pU_north_esa,Vector<IssmDouble>** pU_east_esa,FemModel* femmodel,Vector<IssmDouble>* RSLg, SealevelMasks* masks){ /*{{{*/
    628 
    629         Vector<IssmDouble> *U_esa  = NULL;
    630         Vector<IssmDouble> *U_north_esa   = NULL;
    631         Vector<IssmDouble> *U_east_esa    = NULL;
     676void sealevelchange_core_deformation(Vector<IssmDouble>** pN_grd, Vector<IssmDouble>** pU_grd, Vector<IssmDouble>** pU_north_grd,Vector<IssmDouble>** pU_east_grd,FemModel* femmodel,Vector<IssmDouble>* RSLg, SealevelMasks* masks){ /*{{{*/
     677
     678        Vector<IssmDouble> *U_grd  = NULL;
     679        Vector<IssmDouble> *N_grd  = NULL;
     680        Vector<IssmDouble> *U_north_grd   = NULL;
     681        Vector<IssmDouble> *U_east_grd    = NULL;
    632682
    633683        /*parameters: */
    … …  
    652702
    653703        /*intialize vectors:*/
    654         U_esa = new Vector<IssmDouble>(gsize);
     704        U_grd = new Vector<IssmDouble>(gsize);
     705        N_grd = new Vector<IssmDouble>(gsize);
    655706        if (horiz){
    656                 U_north_esa = new Vector<IssmDouble>(gsize);
    657                 U_east_esa = new Vector<IssmDouble>(gsize);
    658         }
    659 
     707                U_north_grd = new Vector<IssmDouble>(gsize);
     708                U_east_grd = new Vector<IssmDouble>(gsize);
     709        }
     710       
    660711        /*retrieve geometric information: */
    661712        VertexCoordinatesx(&latitude,&longitude,&radius,femmodel->vertices,spherical);
    … …  
    663714
    664715        /*call the elastic main modlule:*/
    665         femmodel->SealevelriseElastic(U_esa,U_north_esa,U_east_esa,RSLg, masks);
     716        femmodel->SealevelchangeDeformation(N_grd, U_grd,U_north_grd,U_east_grd,RSLg, masks);
    666717
    667718        /*Assign output pointers:*/
    668         *pU_esa=U_esa;
     719        *pU_grd=U_grd;
     720        *pN_grd=N_grd;
    669721        if(horiz){
    670                 *pU_east_esa=U_east_esa;
    671                 *pU_north_esa=U_north_esa;
     722                *pU_east_grd=U_east_grd;
     723                *pU_north_grd=U_north_grd;
    672724        }
    673725
    … …  
    681733}
    682734/*}}}*/
    683 void sealevelrise_core_viscous(Vector<IssmDouble>** pU_gia, Vector<IssmDouble>** pN_gia,FemModel* femmodel,Vector<IssmDouble>* RSLg){ /*{{{*/
    684 
    685         /*variables:*/
    686         Vector<IssmDouble> *U_gia  = NULL;
    687         Vector<IssmDouble> *N_gia  = NULL;
    688 
    689         /*parameters:*/
    690         int                                     frequency;
    691         IssmDouble          dt;
    692        
    693         if(VerboseSolution()) _printf0_("         computing viscous components\n");
    694 
    695         /*retrieve some parameters:*/
    696         femmodel->parameters->FindParam(&frequency,SolidearthSettingsRunFrequencyEnum);
    697         femmodel->parameters->FindParam(&dt,TimesteppingTimeStepEnum);
    698 
    699         /*recover GIA rates:*/
    700         GetVectorFromInputsx(&U_gia,femmodel,UGiaRateEnum,VertexSIdEnum);
    701         GetVectorFromInputsx(&N_gia,femmodel,NGiaRateEnum,VertexSIdEnum);
    702 
    703         /*we just loaded rates, that's not what's being asked, scale by time:*/
    704         U_gia->Scale(frequency*dt);
    705         N_gia->Scale(frequency*dt);
    706 
    707         /*Assign output pointers:*/
    708         *pU_gia=U_gia;
    709         *pN_gia=N_gia;
    710 
    711 }
    712 /*}}}*/
    713 void sealevelrise_diagnostics(FemModel* femmodel,Vector<IssmDouble>* RSLg){ /*{{{*/
    714 
    715         /*compute spherical harmonics deg 1 and deg 2 coefficeints:*/
    716 
    717 }
    718 /*}}}*/
     735
     736//Ocean:
    719737void GetDynamicRate(Vector<IssmDouble> ** pdynamic_rate_g, FemModel* femmodel){ /*{{{*/
    720738
    … …  
    837855/*}}}*/
    838856
    839 /*support routines:*/
     857/*Support routines:*/
    840858void TransferForcing(FemModel* femmodel,int forcingenum){ /*{{{*/
    841859
    … …  
    913931
    914932                /*Retrieve transition vectors, used to plug from each ice cap into the global forcing:*/
    915                 femmodel->parameters->FindParam(&transitions,&ntransitions,&transitions_m,&transitions_n,SealevelriseTransitionsEnum);
     933                femmodel->parameters->FindParam(&transitions,&ntransitions,&transitions_m,&transitions_n,SealevelchangeTransitionsEnum);
    916934
    917935                if(ntransitions!=earthid)_error_("TransferForcing error message: number of transition vectors is not equal to the number of icecaps!");
    … …  
    10191037
    10201038                        /*Retrieve transition vectors, used to figure out global forcing contribution to each ice cap's own elements: */
    1021                         femmodel->parameters->FindParam(&transitions,&ntransitions,&transitions_m,&transitions_n,SealevelriseTransitionsEnum);
     1039                        femmodel->parameters->FindParam(&transitions,&ntransitions,&transitions_m,&transitions_n,SealevelchangeTransitionsEnum);
    10221040
    10231041                        if(ntransitions!=earthid)_error_("TransferSeaLevel error message: number of transition vectors is not equal to the number of icecaps!");
    … …  
    10871105        /*This mass transport module for the Earth is because we might have thickness variations as spcs
    10881106         * specified in the md.slr class, outside of what we will get from the icecaps. That's why we get t
    1089          * the thickness variations from SealevelriseSpcthicknessEnum.*/
     1107         * the thickness variations from SealevelchangeSpcthicknessEnum.*/
    10901108
    10911109        /*No mass transport module was called, so we are just going to retrieve the geometry thickness
    … …  
    10951113        nv=femmodel->vertices->NumberOfVertices();
    10961114
    1097         GetVectorFromInputsx(&newthickness,femmodel,SealevelriseSpcthicknessEnum,VertexSIdEnum);
    1098         GetVectorFromInputsx(&oldthickness,femmodel,SealevelriseSpcthicknessEnum,VertexSIdEnum,time-dt);*/
     1115        GetVectorFromInputsx(&newthickness,femmodel,SealevelchangeSpcthicknessEnum,VertexSIdEnum);
     1116        GetVectorFromInputsx(&oldthickness,femmodel,SealevelchangeSpcthicknessEnum,VertexSIdEnum,time-dt);*/
    10991117
    11001118        /*compute deltathickness: */
    … …  
    11061124
    11071125        /*add to cumulated delta thickness: */
    1108         /*GetVectorFromInputsx(&cumdeltathickness,femmodel,SealevelriseCumDeltathicknessEnum,VertexSIdEnum);
     1126        /*GetVectorFromInputsx(&cumdeltathickness,femmodel,SealevelchangeCumDeltathicknessEnum,VertexSIdEnum);
    11091127        cumdeltathickness->AXPY(deltathickness,1);
    1110         InputUpdateFromVectorx(femmodel,cumdeltathickness,SealevelriseCumDeltathicknessEnum,VertexSIdEnum);*/
     1128        InputUpdateFromVectorx(femmodel,cumdeltathickness,SealevelchangeCumDeltathicknessEnum,VertexSIdEnum);*/
    11111129
    11121130        /*free ressources:*/

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

    r25829 r25947  
    6262        #endif
    6363
    64         if(isslr) sealevelrise_core_geometry(femmodel);
     64        if(isslr) sealevelchange_geometry(femmodel);
    6565
    6666        while(time < finaltime - (yts*DBL_EPSILON)){ //make sure we run up to finaltime.
    … …  
    235235        if(isesa) esa_core(femmodel);
    236236
    237         /*Sea level rise: */
     237        /*Sea level change: */
    238238        if(isslr){
    239                 if(VerboseSolution()) _printf0_("   computing sea level rise\n");
     239                if(VerboseSolution()) _printf0_("   computing sea level change\n");
    240240                sealevelchange_core(femmodel);
    241241        }
    … …  
    275275        femmodel->parameters->FindParam(&isslr,TransientIsslrEnum);
    276276        femmodel->parameters->FindParam(&checkpoint_frequency,SettingsCheckpointFrequencyEnum); _assert_(checkpoint_frequency>0);
    277         if(isslr) sealevelrise_core_geometry(femmodel);
     277        if(isslr) sealevelchange_geometry(femmodel);
    278278
    279279        std::vector<IssmDouble> time_all;

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

    r25767 r25947  
    160160
    161161        /*Here, we put all the code that cannot be handled any other place: */
    162         if (strncmp(root,"SurfaceloadModelid",18)==0){
     162        if (strncmp(root,"SurfaceloadModelid",18)==0){ //surface load in solid earth class {{{
    163163
    164164                if(VerboseQmu()){
    … …  
    178178                        MmeToInput(femmodel,distributed_values,variable_partition,npart,MaskOceanLevelsetEnum, P1Enum);
    179179
    180         }
     180        } /*}}}*/
     181        if (strncmp(root,"SolidearthExternalModelid",18)==0){ //external solid earth solution in solid earth class {{{
     182
     183                if(VerboseQmu()){
     184                        _printf0_("      SolidearthExternalModelid MME, with ids: ");
     185                        for (int i=0;i<npart;i++)_printf0_((int)distributed_values[i] << " ");
     186                        _printf0_("\n");
     187                }
     188
     189                if (femmodel->inputs->GetInputObjectEnum(SolidearthExternalDisplacementEastRateEnum)==DatasetInputEnum)
     190                        MmeToInput(femmodel,distributed_values,variable_partition,npart,SolidearthExternalDisplacementEastRateEnum, P1Enum);
     191
     192                if (femmodel->inputs->GetInputObjectEnum(SolidearthExternalDisplacementUpRateEnum)==DatasetInputEnum)
     193                        MmeToInput(femmodel,distributed_values,variable_partition,npart,SolidearthExternalDisplacementUpRateEnum, P1Enum);
     194
     195                if (femmodel->inputs->GetInputObjectEnum(SolidearthExternalDisplacementNorthRateEnum)==DatasetInputEnum)
     196                        MmeToInput(femmodel,distributed_values,variable_partition,npart,SolidearthExternalDisplacementNorthRateEnum, P1Enum);
     197
     198                if (femmodel->inputs->GetInputObjectEnum(SolidearthExternalGeoidRateEnum)==DatasetInputEnum)
     199                        MmeToInput(femmodel,distributed_values,variable_partition,npart,SolidearthExternalGeoidRateEnum, P1Enum);
     200
     201                if (femmodel->inputs->GetInputObjectEnum(SolidearthExternalBarystaticSeaLevelRateEnum)==DatasetInputEnum)
     202                        MmeToInput(femmodel,distributed_values,variable_partition,npart,SolidearthExternalBarystaticSeaLevelRateEnum, P1Enum);
     203        } /*}}}*/
     204
    181205        else _error_("InputUpdateSpecialtyCode error message: " << root << " not supported yet!");
    182206
    … …  
    241265        transientinput2->Configure(femmodel->parameters);
    242266}       //}}}
     267void  MmeToInputFromId(FemModel* femmodel,int id, int rootenum, int interpolationenum){ /*{{{*/
     268
     269        TransientInput* transientinput  = NULL;
     270        TransientInput* transientinput2 = NULL;
     271        Tria* element                    = NULL;
     272        IssmDouble value;
     273        IssmDouble* values               = NULL;
     274        IssmDouble* times                = NULL;
     275        int N;
     276
     277        /*find thickness dataset: */
     278        DatasetInput* datasetinput = femmodel->inputs->GetDatasetInput(rootenum);
     279
     280        /*Initialize new transient input: */
     281        transientinput = datasetinput->GetTransientInputByOffset(0); _assert_(transientinput);
     282        transientinput->GetAllTimes(&times,&N);
     283        femmodel->inputs->SetTransientInput(DummyEnum,times,N);
     284        transientinput2 = femmodel->inputs->GetTransientInput(DummyEnum);
     285
     286        for(Object* & object : femmodel->elements->objects){
     287                Tria*   element=xDynamicCast<Tria*>(object);
     288
     289                /*recover the right field from the mme: */
     290                transientinput = datasetinput->GetTransientInputByOffset(id); _assert_(transientinput);
     291
     292                /*copy values from the transientinput to the final transientinput2: */
     293                for (int j=0;j<N;j++){
     294                        TriaInput* tria_input=transientinput->GetTriaInput(j);
     295                        element->InputServe(tria_input);
     296                        if(interpolationenum==P0Enum){
     297                                value=tria_input->element_values[0];
     298                                transientinput2->AddTriaTimeInput( j,1,&(element->lid),&value,P0Enum);
     299                        }
     300                        else if(interpolationenum==P1Enum){
     301
     302                                /*Get values and lid list*/
     303                                const int   numvertices     = element->GetNumberOfVertices();
     304                                int        *vertexlids      = xNew<int>(numvertices);
     305                                int        *vertexsids      = xNew<int>(numvertices);
     306
     307                                /*Recover vertices ids needed to initialize inputs*/
     308                                element->GetVerticesLidList(&vertexlids[0]);
     309                                element->GetVerticesSidList(&vertexsids[0]);
     310                                values=tria_input->element_values;
     311                                transientinput2->AddTriaTimeInput( j,numvertices,vertexlids,values,P1Enum);
     312                        }
     313                }
     314        }
     315
     316        /*wipe out existing SurfaceloadIceThicknessChangeEnum dataset:*/
     317        femmodel->inputs->ChangeEnum(DummyEnum,rootenum);
     318
     319        //reconfigure:
     320        transientinput2->Configure(femmodel->parameters);
     321}       //}}}
    243322void  InputScaleFromDakotax(FemModel* femmodel,IssmDouble* distributed_values,IssmDouble* partition, int npart, int nt, int name){ /*{{{*/
    244323

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

    r25258 r25947  
    1111void  InputUpdateSpecialtyCode(FemModel* femmodel,IssmDouble* distributed_values,IssmDouble* variable_partition,int npart,char* root);
    1212void  MmeToInput(FemModel* femmodel,IssmDouble* distributed_values,IssmDouble* variable_partition,int npart,int rootenum, int interpolationenum);
     13void  MmeToInputFromId(FemModel* femmodel,int id, int rootenum, int interpolationenum);
    1314void InputScaleFromDakotax(FemModel* femmodel,IssmDouble* distributed_values,IssmDouble* partition, int npart, int nt, int name);
    1415

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

    r25777 r25947  
    6363        parameters->AddObject(iomodel->CopyConstantObject("md.calving.law",CalvingLawEnum));
    6464        parameters->AddObject(iomodel->CopyConstantObject("md.frontalforcings.parameterization",FrontalForcingsParamEnum));
    65         parameters->AddObject(new IntParam(SealevelriseRunCountEnum,1));
     65        parameters->AddObject(new IntParam(SealevelchangeRunCountEnum,1));
    6666
    6767          {/*This is specific to ice...*/

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

    r25942 r25947  
    138138syn keyword cConstant DslModelidEnum
    139139syn keyword cConstant DslNummodelsEnum
     140syn keyword cConstant SolidearthIsExternalEnum
     141syn keyword cConstant SolidearthExternalNatureEnum
     142syn keyword cConstant SolidearthExternalModelidEnum
     143syn keyword cConstant SolidearthExternalNummodelsEnum
    140144syn keyword cConstant DslComputeFingerprintsEnum
    141145syn keyword cConstant EarthIdEnum
    … …  
    338342syn keyword cConstant RotationalAngularVelocityEnum
    339343syn keyword cConstant SolidearthSettingsElasticEnum
    340 syn keyword cConstant SealevelriseGeometryDoneEnum
     344syn keyword cConstant SealevelchangeGeometryDoneEnum
    341345syn keyword cConstant RotationalEquatorialMoiEnum
    342346syn keyword cConstant TidalLoveHEnum
    … …  
    347351syn keyword cConstant LoadLoveKEnum
    348352syn keyword cConstant LoadLoveLEnum
    349 syn keyword cConstant SealevelriseGRigidEnum
    350 syn keyword cConstant SealevelriseGElasticEnum
     353syn keyword cConstant SealevelchangeGRigidEnum
     354syn keyword cConstant SealevelchangeGElasticEnum
    351355syn keyword cConstant SolidearthSettingsComputesealevelchangeEnum
    352356syn keyword cConstant SolidearthSettingsGRDEnum
    353357syn keyword cConstant SolidearthSettingsGlfractionEnum
    354358syn keyword cConstant SolidearthSettingsRunFrequencyEnum
    355 syn keyword cConstant SealevelriseHElasticEnum
     359syn keyword cConstant SealevelchangeHElasticEnum
    356360syn keyword cConstant SolidearthSettingsHorizEnum
    357361syn keyword cConstant SolidearthSettingsMaxiterEnum
    … …  
    359363syn keyword cConstant RotationalPolarMoiEnum
    360364syn keyword cConstant SolidearthSettingsReltolEnum
    361 syn keyword cConstant SealevelriseRequestedOutputsEnum
     365syn keyword cConstant SealevelchangeRequestedOutputsEnum
    362366syn keyword cConstant SolidearthSettingsRigidEnum
    363367syn keyword cConstant SolidearthSettingsRotationEnum
    364 syn keyword cConstant SealevelriseRunCountEnum
    365 syn keyword cConstant SealevelriseTransitionsEnum
    366 syn keyword cConstant SealevelriseUElasticEnum
     368syn keyword cConstant SealevelchangeRunCountEnum
     369syn keyword cConstant SealevelchangeTransitionsEnum
     370syn keyword cConstant SealevelchangeUElasticEnum
    367371syn keyword cConstant SettingsIoGatherEnum
    368372syn keyword cConstant SettingsNumResultsOnNodesEnum
    … …  
    532536syn keyword cConstant BaseSlopeYEnum
    533537syn keyword cConstant BedEnum
     538syn keyword cConstant BedEastEnum
     539syn keyword cConstant BedNorthEnum
    534540syn keyword cConstant BedSlopeXEnum
    535541syn keyword cConstant BedSlopeYEnum
    … …  
    710716syn keyword cConstant RheologyBbarAbsGradientEnum
    711717syn keyword cConstant SealevelEnum
    712 syn keyword cConstant SealevelEustaticMaskEnum
    713 syn keyword cConstant SealevelEustaticOceanMaskEnum
     718syn keyword cConstant SealevelBarystaticMaskEnum
     719syn keyword cConstant SealevelBarystaticOceanMaskEnum
    714720syn keyword cConstant SealevelNEsaEnum
    715721syn keyword cConstant SealevelNEsaRateEnum
    … …  
    720726syn keyword cConstant BslrRateEnum
    721727syn keyword cConstant GmtslrEnum
    722 syn keyword cConstant SealevelRSLEustaticEnum
    723 syn keyword cConstant SealevelRSLEustaticRateEnum
     728syn keyword cConstant SealevelRSLBarystaticEnum
    724729syn keyword cConstant SealevelRSLRateEnum
    725730syn keyword cConstant SealevelUEastEsaEnum
    … …  
    727732syn keyword cConstant SealevelUEsaRateEnum
    728733syn keyword cConstant SealevelUNorthEsaEnum
    729 syn keyword cConstant SealevelriseCumDeltathicknessEnum
    730 syn keyword cConstant SealevelriseCumDeltathicknessOldEnum
     734syn keyword cConstant SealevelchangeCumDeltathicknessEnum
     735syn keyword cConstant SealevelchangeCumDeltathicknessOldEnum
    731736syn keyword cConstant SurfaceloadOtherEnum
    732737syn keyword cConstant SurfaceloadIceThicknessChangeEnum
    733738syn keyword cConstant SurfaceloadWaterHeightChangeEnum
    734 syn keyword cConstant SealevelriseIndicesEnum
    735 syn keyword cConstant SealevelriseGEnum
    736 syn keyword cConstant SealevelriseGUEnum
    737 syn keyword cConstant SealevelriseGEEnum
    738 syn keyword cConstant SealevelriseGNEnum
     739syn keyword cConstant SealevelchangeIndicesEnum
     740syn keyword cConstant SealevelchangeGEnum
     741syn keyword cConstant SealevelchangeGUEnum
     742syn keyword cConstant SealevelchangeGEEnum
     743syn keyword cConstant SealevelchangeGNEnum
    739744syn keyword cConstant SedimentHeadEnum
    740745syn keyword cConstant SedimentHeadOldEnum
    … …  
    844849syn keyword cConstant SmbZTopEnum
    845850syn keyword cConstant SmbZYEnum
     851syn keyword cConstant SolidearthExternalDisplacementEastRateEnum
     852syn keyword cConstant SolidearthExternalDisplacementNorthRateEnum
     853syn keyword cConstant SolidearthExternalDisplacementUpRateEnum
     854syn keyword cConstant SolidearthExternalGeoidRateEnum
     855syn keyword cConstant SolidearthExternalBarystaticSeaLevelRateEnum
    846856syn keyword cConstant StrainRateeffectiveEnum
    847857syn keyword cConstant StrainRateparallelEnum
    … …  
    13031313syn keyword cConstant SealevelNmotionEnum
    13041314syn keyword cConstant SealevelUmotionEnum
    1305 syn keyword cConstant SealevelriseAnalysisEnum
    1306 syn keyword cConstant SealevelriseSolutionEnum
     1315syn keyword cConstant SealevelchangeAnalysisEnum
     1316syn keyword cConstant SealevelchangeSolutionEnum
    13071317syn keyword cConstant SegEnum
    13081318syn keyword cConstant SegInputEnum
    … …  
    13991409syn keyword cType Cfsurfacesquare
    14001410syn keyword cType Channel
    1401 syn keyword cType classes
    14021411syn keyword cType Constraint
    14031412syn keyword cType Constraints
    … …  
    14061415syn keyword cType ControlInput
    14071416syn keyword cType Covertree
     1417syn keyword cType DataSetParam
    14081418syn keyword cType DatasetInput
    1409 syn keyword cType DataSetParam
    14101419syn keyword cType Definition
    14111420syn keyword cType DependentObject
    … …  
    14201429syn keyword cType ElementInput
    14211430syn keyword cType ElementMatrix
     1431syn keyword cType ElementVector
    14221432syn keyword cType Elements
    1423 syn keyword cType ElementVector
    14241433syn keyword cType ExponentialVariogram
    14251434syn keyword cType ExternalResult
    … …  
    14281437syn keyword cType Friction
    14291438syn keyword cType Gauss
    1430 syn keyword cType GaussianVariogram
    1431 syn keyword cType gaussobjects
    14321439syn keyword cType GaussPenta
    14331440syn keyword cType GaussSeg
    14341441syn keyword cType GaussTetra
    14351442syn keyword cType GaussTria
     1443syn keyword cType GaussianVariogram
    14361444syn keyword cType GenericExternalResult
    14371445syn keyword cType GenericOption
    … …  
    14481456syn keyword cType IssmDirectApplicInterface
    14491457syn keyword cType IssmParallelDirectApplicInterface
    1450 syn keyword cType krigingobjects
    14511458syn keyword cType Load
    14521459syn keyword cType Loads
    … …  
    14591466syn keyword cType Matice
    14601467syn keyword cType Matlitho
    1461 syn keyword cType matrixobjects
    14621468syn keyword cType MatrixParam
    14631469syn keyword cType Misfit
    … …  
    14721478syn keyword cType Observations
    14731479syn keyword cType Option
     1480syn keyword cType OptionUtilities
    14741481syn keyword cType Options
    1475 syn keyword cType OptionUtilities
    14761482syn keyword cType Param
    14771483syn keyword cType Parameters
    … …  
    14871493syn keyword cType Regionaloutput
    14881494syn keyword cType Results
     1495syn keyword cType RiftStruct
    14891496syn keyword cType Riftfront
    1490 syn keyword cType RiftStruct
    14911497syn keyword cType SealevelMasks
    14921498syn keyword cType Seg
    14931499syn keyword cType SegInput
     1500syn keyword cType SegRef
    14941501syn keyword cType Segment
    1495 syn keyword cType SegRef
    14961502syn keyword cType SpcDynamic
    14971503syn keyword cType SpcStatic
    … …  
    15121518syn keyword cType Vertex
    15131519syn keyword cType Vertices
     1520syn keyword cType classes
     1521syn keyword cType gaussobjects
     1522syn keyword cType krigingobjects
     1523syn keyword cType matrixobjects
    15141524syn keyword cType AdjointBalancethickness2Analysis
    15151525syn keyword cType AdjointBalancethicknessAnalysis
    … …  
    15301540syn keyword cType FreeSurfaceBaseAnalysis
    15311541syn keyword cType FreeSurfaceTopAnalysis
     1542syn keyword cType GLheightadvectionAnalysis
    15321543syn keyword cType GiaAnalysis
    1533 syn keyword cType GLheightadvectionAnalysis
    15341544syn keyword cType HydrologyDCEfficientAnalysis
    15351545syn keyword cType HydrologyDCInefficientAnalysis
    … …  
    15441554syn keyword cType MasstransportAnalysis
    15451555syn keyword cType MeltingAnalysis
    1546 syn keyword cType SealevelriseAnalysis
     1556syn keyword cType SealevelchangeAnalysis
    15471557syn keyword cType SmbAnalysis
    15481558syn keyword cType SmoothAnalysis

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

    r25942 r25947  
    132132        DslModelidEnum,
    133133        DslNummodelsEnum,
     134        SolidearthIsExternalEnum,
     135        SolidearthExternalNatureEnum,
     136        SolidearthExternalModelidEnum,
     137        SolidearthExternalNummodelsEnum,
    134138        DslComputeFingerprintsEnum,
    135139        EarthIdEnum,
    … …  
    332336        RotationalAngularVelocityEnum,
    333337        SolidearthSettingsElasticEnum,
    334         SealevelriseGeometryDoneEnum,
     338        SealevelchangeGeometryDoneEnum,
    335339        RotationalEquatorialMoiEnum,
    336340        TidalLoveHEnum,
    … …  
    341345        LoadLoveKEnum,
    342346        LoadLoveLEnum,
    343         SealevelriseGRigidEnum,
    344         SealevelriseGElasticEnum,
     347        SealevelchangeGRigidEnum,
     348        SealevelchangeGElasticEnum,
    345349        SolidearthSettingsComputesealevelchangeEnum,
    346350        SolidearthSettingsGRDEnum,
    347351        SolidearthSettingsGlfractionEnum,
    348352        SolidearthSettingsRunFrequencyEnum,
    349         SealevelriseHElasticEnum,
     353        SealevelchangeHElasticEnum,
    350354        SolidearthSettingsHorizEnum,
    351355        SolidearthSettingsMaxiterEnum,
    … …  
    353357        RotationalPolarMoiEnum,
    354358        SolidearthSettingsReltolEnum,
    355         SealevelriseRequestedOutputsEnum,
     359        SealevelchangeRequestedOutputsEnum,
    356360        SolidearthSettingsRigidEnum,
    357361        SolidearthSettingsRotationEnum,
    358         SealevelriseRunCountEnum,
    359         SealevelriseTransitionsEnum,
    360         SealevelriseUElasticEnum,
     362        SealevelchangeRunCountEnum,
     363        SealevelchangeTransitionsEnum,
     364        SealevelchangeUElasticEnum,
    361365        SettingsIoGatherEnum,
    362366        SettingsNumResultsOnNodesEnum,
    … …  
    528532        BaseSlopeYEnum,
    529533        BedEnum,
     534        BedEastEnum,
     535        BedNorthEnum,
    530536        BedSlopeXEnum,
    531537        BedSlopeYEnum,
    … …  
    706712        RheologyBbarAbsGradientEnum,
    707713        SealevelEnum,
    708         SealevelEustaticMaskEnum,
    709         SealevelEustaticOceanMaskEnum,
     714        SealevelBarystaticMaskEnum,
     715        SealevelBarystaticOceanMaskEnum,
    710716        SealevelNEsaEnum,
    711717        SealevelNEsaRateEnum,
    … …  
    716722        BslrRateEnum,
    717723        GmtslrEnum,
    718         SealevelRSLEustaticEnum,
    719         SealevelRSLEustaticRateEnum,
     724        SealevelRSLBarystaticEnum,
    720725        SealevelRSLRateEnum,
    721726        SealevelUEastEsaEnum,
    … …  
    723728        SealevelUEsaRateEnum,
    724729        SealevelUNorthEsaEnum,
    725         SealevelriseCumDeltathicknessEnum,
    726         SealevelriseCumDeltathicknessOldEnum,
     730        SealevelchangeCumDeltathicknessEnum,
     731        SealevelchangeCumDeltathicknessOldEnum,
    727732        SurfaceloadOtherEnum,
    728733        SurfaceloadIceThicknessChangeEnum,
    729734        SurfaceloadWaterHeightChangeEnum,
    730         SealevelriseIndicesEnum,
    731         SealevelriseGEnum,
    732         SealevelriseGUEnum,
    733         SealevelriseGEEnum,
    734         SealevelriseGNEnum,
     735        SealevelchangeIndicesEnum,
     736        SealevelchangeGEnum,
     737        SealevelchangeGUEnum,
     738        SealevelchangeGEEnum,
     739        SealevelchangeGNEnum,
    735740        SedimentHeadEnum,
    736741        SedimentHeadOldEnum,
    … …  
    841846        SmbZTopEnum,
    842847        SmbZYEnum,
     848        SolidearthExternalDisplacementEastRateEnum,
     849        SolidearthExternalDisplacementNorthRateEnum,
     850        SolidearthExternalDisplacementUpRateEnum,
     851        SolidearthExternalGeoidRateEnum,
     852        SolidearthExternalBarystaticSeaLevelRateEnum,
    843853        StrainRateeffectiveEnum,
    844854        StrainRateparallelEnum,
    … …  
    13021312        SealevelNmotionEnum,
    13031313        SealevelUmotionEnum,
    1304         SealevelriseAnalysisEnum,
    1305         SealevelriseSolutionEnum,
     1314        SealevelchangeAnalysisEnum,
     1315        SealevelchangeSolutionEnum,
    13061316        SegEnum,
    13071317        SegInputEnum,

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

    r25839 r25947  
    140140                case DslModelidEnum : return "DslModelid";
    141141                case DslNummodelsEnum : return "DslNummodels";
     142                case SolidearthIsExternalEnum : return "SolidearthIsExternal";
     143                case SolidearthExternalNatureEnum : return "SolidearthExternalNature";
     144                case SolidearthExternalModelidEnum : return "SolidearthExternalModelid";
     145                case SolidearthExternalNummodelsEnum : return "SolidearthExternalNummodels";
    142146                case DslComputeFingerprintsEnum : return "DslComputeFingerprints";
    143147                case EarthIdEnum : return "EarthId";
    … …  
    340344                case RotationalAngularVelocityEnum : return "RotationalAngularVelocity";
    341345                case SolidearthSettingsElasticEnum : return "SolidearthSettingsElastic";
    342                 case SealevelriseGeometryDoneEnum : return "SealevelriseGeometryDone";
     346                case SealevelchangeGeometryDoneEnum : return "SealevelchangeGeometryDone";
    343347                case RotationalEquatorialMoiEnum : return "RotationalEquatorialMoi";
    344348                case TidalLoveHEnum : return "TidalLoveH";
    … …  
    349353                case LoadLoveKEnum : return "LoadLoveK";
    350354                case LoadLoveLEnum : return "LoadLoveL";
    351                 case SealevelriseGRigidEnum : return "SealevelriseGRigid";
    352                 case SealevelriseGElasticEnum : return "SealevelriseGElastic";
     355                case SealevelchangeGRigidEnum : return "SealevelchangeGRigid";
     356                case SealevelchangeGElasticEnum : return "SealevelchangeGElastic";
    353357                case SolidearthSettingsComputesealevelchangeEnum : return "SolidearthSettingsComputesealevelchange";
    354358                case SolidearthSettingsGRDEnum : return "SolidearthSettingsGRD";
    355359                case SolidearthSettingsGlfractionEnum : return "SolidearthSettingsGlfraction";
    356360                case SolidearthSettingsRunFrequencyEnum : return "SolidearthSettingsRunFrequency";
    357                 case SealevelriseHElasticEnum : return "SealevelriseHElastic";
     361                case SealevelchangeHElasticEnum : return "SealevelchangeHElastic";
    358362                case SolidearthSettingsHorizEnum : return "SolidearthSettingsHoriz";
    359363                case SolidearthSettingsMaxiterEnum : return "SolidearthSettingsMaxiter";
    … …  
    361365                case RotationalPolarMoiEnum : return "RotationalPolarMoi";
    362366                case SolidearthSettingsReltolEnum : return "SolidearthSettingsReltol";
    363                 case SealevelriseRequestedOutputsEnum : return "SealevelriseRequestedOutputs";
     367                case SealevelchangeRequestedOutputsEnum : return "SealevelchangeRequestedOutputs";
    364368                case SolidearthSettingsRigidEnum : return "SolidearthSettingsRigid";
    365369                case SolidearthSettingsRotationEnum : return "SolidearthSettingsRotation";
    366                 case SealevelriseRunCountEnum : return "SealevelriseRunCount";
    367                 case SealevelriseTransitionsEnum : return "SealevelriseTransitions";
    368                 case SealevelriseUElasticEnum : return "SealevelriseUElastic";
     370                case SealevelchangeRunCountEnum : return "SealevelchangeRunCount";
     371                case SealevelchangeTransitionsEnum : return "SealevelchangeTransitions";
     372                case SealevelchangeUElasticEnum : return "SealevelchangeUElastic";
    369373                case SettingsIoGatherEnum : return "SettingsIoGather";
    370374                case SettingsNumResultsOnNodesEnum : return "SettingsNumResultsOnNodes";
    … …  
    534538                case BaseSlopeYEnum : return "BaseSlopeY";
    535539                case BedEnum : return "Bed";
     540                case BedEastEnum : return "BedEast";
     541                case BedNorthEnum : return "BedNorth";
    536542                case BedSlopeXEnum : return "BedSlopeX";
    537543                case BedSlopeYEnum : return "BedSlopeY";
    … …  
    712718                case RheologyBbarAbsGradientEnum : return "RheologyBbarAbsGradient";
    713719                case SealevelEnum : return "Sealevel";
    714                 case SealevelEustaticMaskEnum : return "SealevelEustaticMask";
    715                 case SealevelEustaticOceanMaskEnum : return "SealevelEustaticOceanMask";
     720                case SealevelBarystaticMaskEnum : return "SealevelBarystaticMask";
     721                case SealevelBarystaticOceanMaskEnum : return "SealevelBarystaticOceanMask";
    716722                case SealevelNEsaEnum : return "SealevelNEsa";
    717723                case SealevelNEsaRateEnum : return "SealevelNEsaRate";
    … …  
    722728                case BslrRateEnum : return "BslrRate";
    723729                case GmtslrEnum : return "Gmtslr";
    724                 case SealevelRSLEustaticEnum : return "SealevelRSLEustatic";
    725                 case SealevelRSLEustaticRateEnum : return "SealevelRSLEustaticRate";
     730                case SealevelRSLBarystaticEnum : return "SealevelRSLBarystatic";
    726731                case SealevelRSLRateEnum : return "SealevelRSLRate";
    727732                case SealevelUEastEsaEnum : return "SealevelUEastEsa";
    … …  
    729734                case SealevelUEsaRateEnum : return "SealevelUEsaRate";
    730735                case SealevelUNorthEsaEnum : return "SealevelUNorthEsa";
    731                 case SealevelriseCumDeltathicknessEnum : return "SealevelriseCumDeltathickness";
    732                 case SealevelriseCumDeltathicknessOldEnum : return "SealevelriseCumDeltathicknessOld";
     736                case SealevelchangeCumDeltathicknessEnum : return "SealevelchangeCumDeltathickness";
     737                case SealevelchangeCumDeltathicknessOldEnum : return "SealevelchangeCumDeltathicknessOld";
    733738                case SurfaceloadOtherEnum : return "SurfaceloadOther";
    734739                case SurfaceloadIceThicknessChangeEnum : return "SurfaceloadIceThicknessChange";
    735740                case SurfaceloadWaterHeightChangeEnum : return "SurfaceloadWaterHeightChange";
    736                 case SealevelriseIndicesEnum : return "SealevelriseIndices";
    737                 case SealevelriseGEnum : return "SealevelriseG";
    738                 case SealevelriseGUEnum : return "SealevelriseGU";
    739                 case SealevelriseGEEnum : return "SealevelriseGE";
    740                 case SealevelriseGNEnum : return "SealevelriseGN";
     741                case SealevelchangeIndicesEnum : return "SealevelchangeIndices";
     742                case SealevelchangeGEnum : return "SealevelchangeG";
     743                case SealevelchangeGUEnum : return "SealevelchangeGU";
     744                case SealevelchangeGEEnum : return "SealevelchangeGE";
     745                case SealevelchangeGNEnum : return "SealevelchangeGN";
    741746                case SedimentHeadEnum : return "SedimentHead";
    742747                case SedimentHeadOldEnum : return "SedimentHeadOld";
    … …  
    846851                case SmbZTopEnum : return "SmbZTop";
    847852                case SmbZYEnum : return "SmbZY";
     853                case SolidearthExternalDisplacementEastRateEnum : return "SolidearthExternalDisplacementEastRate";
     854                case SolidearthExternalDisplacementNorthRateEnum : return "SolidearthExternalDisplacementNorthRate";
     855                case SolidearthExternalDisplacementUpRateEnum : return "SolidearthExternalDisplacementUpRate";
     856                case SolidearthExternalGeoidRateEnum : return "SolidearthExternalGeoidRate";
     857                case SolidearthExternalBarystaticSeaLevelRateEnum : return "SolidearthExternalBarystaticSeaLevelRate";
    848858                case StrainRateeffectiveEnum : return "StrainRateeffective";
    849859                case StrainRateparallelEnum : return "StrainRateparallel";
    … …  
    13051315                case SealevelNmotionEnum : return "SealevelNmotion";
    13061316                case SealevelUmotionEnum : return "SealevelUmotion";
    1307                 case SealevelriseAnalysisEnum : return "SealevelriseAnalysis";
    1308                 case SealevelriseSolutionEnum : return "SealevelriseSolution";
     1317                case SealevelchangeAnalysisEnum : return "SealevelchangeAnalysis";
     1318                case SealevelchangeSolutionEnum : return "SealevelchangeSolution";
    13091319                case SegEnum : return "Seg";
    13101320                case SegInputEnum : return "SegInput";

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

    r25839 r25947  
    143143              else if (strcmp(name,"DslModelid")==0) return DslModelidEnum;
    144144              else if (strcmp(name,"DslNummodels")==0) return DslNummodelsEnum;
     145              else if (strcmp(name,"SolidearthIsExternal")==0) return SolidearthIsExternalEnum;
     146              else if (strcmp(name,"SolidearthExternalNature")==0) return SolidearthExternalNatureEnum;
     147              else if (strcmp(name,"SolidearthExternalModelid")==0) return SolidearthExternalModelidEnum;
     148              else if (strcmp(name,"SolidearthExternalNummodels")==0) return SolidearthExternalNummodelsEnum;
    145149              else if (strcmp(name,"DslComputeFingerprints")==0) return DslComputeFingerprintsEnum;
    146150              else if (strcmp(name,"EarthId")==0) return EarthIdEnum;
    … …  
    256260              else if (strcmp(name,"LoveFrequencies")==0) return LoveFrequenciesEnum;
    257261              else if (strcmp(name,"LoveG0")==0) return LoveG0Enum;
    258               else if (strcmp(name,"LoveKernels")==0) return LoveKernelsEnum;
     262         else stage=3;
     263   }
     264   if(stage==3){
     265              if (strcmp(name,"LoveKernels")==0) return LoveKernelsEnum;
    259266              else if (strcmp(name,"LoveMu0")==0) return LoveMu0Enum;
    260267              else if (strcmp(name,"LoveNfreq")==0) return LoveNfreqEnum;
    261268              else if (strcmp(name,"LoveR0")==0) return LoveR0Enum;
    262          else stage=3;
    263    }
    264    if(stage==3){
    265               if (strcmp(name,"LoveShNmax")==0) return LoveShNmaxEnum;
     269              else if (strcmp(name,"LoveShNmax")==0) return LoveShNmaxEnum;
    266270              else if (strcmp(name,"LoveShNmin")==0) return LoveShNminEnum;
    267271              else if (strcmp(name,"MassFluxSegments")==0) return MassFluxSegmentsEnum;
    … …  
    346350              else if (strcmp(name,"RotationalAngularVelocity")==0) return RotationalAngularVelocityEnum;
    347351              else if (strcmp(name,"SolidearthSettingsElastic")==0) return SolidearthSettingsElasticEnum;
    348               else if (strcmp(name,"SealevelriseGeometryDone")==0) return SealevelriseGeometryDoneEnum;
     352              else if (strcmp(name,"SealevelchangeGeometryDone")==0) return SealevelchangeGeometryDoneEnum;
    349353              else if (strcmp(name,"RotationalEquatorialMoi")==0) return RotationalEquatorialMoiEnum;
    350354              else if (strcmp(name,"TidalLoveH")==0) return TidalLoveHEnum;
    … …  
    355359              else if (strcmp(name,"LoadLoveK")==0) return LoadLoveKEnum;
    356360              else if (strcmp(name,"LoadLoveL")==0) return LoadLoveLEnum;
    357               else if (strcmp(name,"SealevelriseGRigid")==0) return SealevelriseGRigidEnum;
    358               else if (strcmp(name,"SealevelriseGElastic")==0) return SealevelriseGElasticEnum;
     361              else if (strcmp(name,"SealevelchangeGRigid")==0) return SealevelchangeGRigidEnum;
     362              else if (strcmp(name,"SealevelchangeGElastic")==0) return SealevelchangeGElasticEnum;
    359363              else if (strcmp(name,"SolidearthSettingsComputesealevelchange")==0) return SolidearthSettingsComputesealevelchangeEnum;
    360364              else if (strcmp(name,"SolidearthSettingsGRD")==0) return SolidearthSettingsGRDEnum;
    361365              else if (strcmp(name,"SolidearthSettingsGlfraction")==0) return SolidearthSettingsGlfractionEnum;
    362366              else if (strcmp(name,"SolidearthSettingsRunFrequency")==0) return SolidearthSettingsRunFrequencyEnum;
    363               else if (strcmp(name,"SealevelriseHElastic")==0) return SealevelriseHElasticEnum;
     367              else if (strcmp(name,"SealevelchangeHElastic")==0) return SealevelchangeHElasticEnum;
    364368              else if (strcmp(name,"SolidearthSettingsHoriz")==0) return SolidearthSettingsHorizEnum;
    365369              else if (strcmp(name,"SolidearthSettingsMaxiter")==0) return SolidearthSettingsMaxiterEnum;
    … …  
    367371              else if (strcmp(name,"RotationalPolarMoi")==0) return RotationalPolarMoiEnum;
    368372              else if (strcmp(name,"SolidearthSettingsReltol")==0) return SolidearthSettingsReltolEnum;
    369               else if (strcmp(name,"SealevelriseRequestedOutputs")==0) return SealevelriseRequestedOutputsEnum;
     373              else if (strcmp(name,"SealevelchangeRequestedOutputs")==0) return SealevelchangeRequestedOutputsEnum;
    370374              else if (strcmp(name,"SolidearthSettingsRigid")==0) return SolidearthSettingsRigidEnum;
    371375              else if (strcmp(name,"SolidearthSettingsRotation")==0) return SolidearthSettingsRotationEnum;
    372               else if (strcmp(name,"SealevelriseRunCount")==0) return SealevelriseRunCountEnum;
    373               else if (strcmp(name,"SealevelriseTransitions")==0) return SealevelriseTransitionsEnum;
    374               else if (strcmp(name,"SealevelriseUElastic")==0) return SealevelriseUElasticEnum;
     376              else if (strcmp(name,"SealevelchangeRunCount")==0) return SealevelchangeRunCountEnum;
     377              else if (strcmp(name,"SealevelchangeTransitions")==0) return SealevelchangeTransitionsEnum;
     378              else if (strcmp(name,"SealevelchangeUElastic")==0) return SealevelchangeUElasticEnum;
    375379              else if (strcmp(name,"SettingsIoGather")==0) return SettingsIoGatherEnum;
    376380              else if (strcmp(name,"SettingsNumResultsOnNodes")==0) return SettingsNumResultsOnNodesEnum;
    … …  
    379383              else if (strcmp(name,"SettingsResultsOnNodes")==0) return SettingsResultsOnNodesEnum;
    380384              else if (strcmp(name,"SettingsSbCouplingFrequency")==0) return SettingsSbCouplingFrequencyEnum;
    381               else if (strcmp(name,"SettingsSolverResidueThreshold")==0) return SettingsSolverResidueThresholdEnum;
     385         else stage=4;
     386   }
     387   if(stage==4){
     388              if (strcmp(name,"SettingsSolverResidueThreshold")==0) return SettingsSolverResidueThresholdEnum;
    382389              else if (strcmp(name,"SettingsWaitonlock")==0) return SettingsWaitonlockEnum;
    383390              else if (strcmp(name,"SmbAIce")==0) return SmbAIceEnum;
    384391              else if (strcmp(name,"SmbAIdx")==0) return SmbAIdxEnum;
    385          else stage=4;
    386    }
    387    if(stage==4){
    388               if (strcmp(name,"SmbASnow")==0) return SmbASnowEnum;
     392              else if (strcmp(name,"SmbASnow")==0) return SmbASnowEnum;
    389393              else if (strcmp(name,"SmbAccualti")==0) return SmbAccualtiEnum;
    390394              else if (strcmp(name,"SmbAccugrad")==0) return SmbAccugradEnum;
    … …  
    502506              else if (strcmp(name,"TransientRequestedOutputs")==0) return TransientRequestedOutputsEnum;
    503507              else if (strcmp(name,"Velocity")==0) return VelocityEnum;
    504               else if (strcmp(name,"WorldComm")==0) return WorldCommEnum;
     508         else stage=5;
     509   }
     510   if(stage==5){
     511              if (strcmp(name,"WorldComm")==0) return WorldCommEnum;
    505512              else if (strcmp(name,"ParametersEND")==0) return ParametersENDEnum;
    506513              else if (strcmp(name,"InputsSTART")==0) return InputsSTARTEnum;
    507514              else if (strcmp(name,"Adjoint")==0) return AdjointEnum;
    508          else stage=5;
    509    }
    510    if(stage==5){
    511               if (strcmp(name,"Adjointp")==0) return AdjointpEnum;
     515              else if (strcmp(name,"Adjointp")==0) return AdjointpEnum;
    512516              else if (strcmp(name,"Adjointx")==0) return AdjointxEnum;
    513517              else if (strcmp(name,"Adjointy")==0) return AdjointyEnum;
    … …  
    546550              else if (strcmp(name,"BaseSlopeY")==0) return BaseSlopeYEnum;
    547551              else if (strcmp(name,"Bed")==0) return BedEnum;
     552              else if (strcmp(name,"BedEast")==0) return BedEastEnum;
     553              else if (strcmp(name,"BedNorth")==0) return BedNorthEnum;
    548554              else if (strcmp(name,"BedSlopeX")==0) return BedSlopeXEnum;
    549555              else if (strcmp(name,"BedSlopeY")==0) return BedSlopeYEnum;
    … …  
    623629              else if (strcmp(name,"FrictionCoefficientcoulomb")==0) return FrictionCoefficientcoulombEnum;
    624630              else if (strcmp(name,"FrictionEffectivePressure")==0) return FrictionEffectivePressureEnum;
    625               else if (strcmp(name,"FrictionM")==0) return FrictionMEnum;
     631         else stage=6;
     632   }
     633   if(stage==6){
     634              if (strcmp(name,"FrictionM")==0) return FrictionMEnum;
    626635              else if (strcmp(name,"FrictionP")==0) return FrictionPEnum;
    627636              else if (strcmp(name,"FrictionPressureAdjustedTemperature")==0) return FrictionPressureAdjustedTemperatureEnum;
    … …  
    629638              else if (strcmp(name,"FrictionSedimentCompressibilityCoefficient")==0) return FrictionSedimentCompressibilityCoefficientEnum;
    630639              else if (strcmp(name,"FrictionTillFrictionAngle")==0) return FrictionTillFrictionAngleEnum;
    631          else stage=6;
    632    }
    633    if(stage==6){
    634               if (strcmp(name,"FrictionWaterLayer")==0) return FrictionWaterLayerEnum;
     640              else if (strcmp(name,"FrictionWaterLayer")==0) return FrictionWaterLayerEnum;
    635641              else if (strcmp(name,"Frictionf")==0) return FrictionfEnum;
    636642              else if (strcmp(name,"FrontalForcingsBasinId")==0) return FrontalForcingsBasinIdEnum;
    … …  
    727733              else if (strcmp(name,"RheologyBbarAbsGradient")==0) return RheologyBbarAbsGradientEnum;
    728734              else if (strcmp(name,"Sealevel")==0) return SealevelEnum;
    729               else if (strcmp(name,"SealevelEustaticMask")==0) return SealevelEustaticMaskEnum;
    730               else if (strcmp(name,"SealevelEustaticOceanMask")==0) return SealevelEustaticOceanMaskEnum;
     735              else if (strcmp(name,"SealevelBarystaticMask")==0) return SealevelBarystaticMaskEnum;
     736              else if (strcmp(name,"SealevelBarystaticOceanMask")==0) return SealevelBarystaticOceanMaskEnum;
    731737              else if (strcmp(name,"SealevelNEsa")==0) return SealevelNEsaEnum;
    732738              else if (strcmp(name,"SealevelNEsaRate")==0) return SealevelNEsaRateEnum;
    … …  
    737743              else if (strcmp(name,"BslrRate")==0) return BslrRateEnum;
    738744              else if (strcmp(name,"Gmtslr")==0) return GmtslrEnum;
    739               else if (strcmp(name,"SealevelRSLEustatic")==0) return SealevelRSLEustaticEnum;
    740               else if (strcmp(name,"SealevelRSLEustaticRate")==0) return SealevelRSLEustaticRateEnum;
     745              else if (strcmp(name,"SealevelRSLBarystatic")==0) return SealevelRSLBarystaticEnum;
    741746              else if (strcmp(name,"SealevelRSLRate")==0) return SealevelRSLRateEnum;
    742747              else if (strcmp(name,"SealevelUEastEsa")==0) return SealevelUEastEsaEnum;
    … …  
    744749              else if (strcmp(name,"SealevelUEsaRate")==0) return SealevelUEsaRateEnum;
    745750              else if (strcmp(name,"SealevelUNorthEsa")==0) return SealevelUNorthEsaEnum;
    746               else if (strcmp(name,"SealevelriseCumDeltathickness")==0) return SealevelriseCumDeltathicknessEnum;
    747               else if (strcmp(name,"SealevelriseCumDeltathicknessOld")==0) return SealevelriseCumDeltathicknessOldEnum;
     751              else if (strcmp(name,"SealevelchangeCumDeltathickness")==0) return SealevelchangeCumDeltathicknessEnum;
     752              else if (strcmp(name,"SealevelchangeCumDeltathicknessOld")==0) return SealevelchangeCumDeltathicknessOldEnum;
    748753              else if (strcmp(name,"SurfaceloadOther")==0) return SurfaceloadOtherEnum;
    749               else if (strcmp(name,"SurfaceloadIceThicknessChange")==0) return SurfaceloadIceThicknessChangeEnum;
    750               else if (strcmp(name,"SurfaceloadWaterHeightChange")==0) return SurfaceloadWaterHeightChangeEnum;
    751               else if (strcmp(name,"SealevelriseIndices")==0) return SealevelriseIndicesEnum;
    752               else if (strcmp(name,"SealevelriseG")==0) return SealevelriseGEnum;
    753               else if (strcmp(name,"SealevelriseGU")==0) return SealevelriseGUEnum;
    754754         else stage=7;
    755755   }
    756756   if(stage==7){
    757               if (strcmp(name,"SealevelriseGE")==0) return SealevelriseGEEnum;
    758               else if (strcmp(name,"SealevelriseGN")==0) return SealevelriseGNEnum;
     757              if (strcmp(name,"SurfaceloadIceThicknessChange")==0) return SurfaceloadIceThicknessChangeEnum;
     758              else if (strcmp(name,"SurfaceloadWaterHeightChange")==0) return SurfaceloadWaterHeightChangeEnum;
     759              else if (strcmp(name,"SealevelchangeIndices")==0) return SealevelchangeIndicesEnum;
     760              else if (strcmp(name,"SealevelchangeG")==0) return SealevelchangeGEnum;
     761              else if (strcmp(name,"SealevelchangeGU")==0) return SealevelchangeGUEnum;
     762              else if (strcmp(name,"SealevelchangeGE")==0) return SealevelchangeGEEnum;
     763              else if (strcmp(name,"SealevelchangeGN")==0) return SealevelchangeGNEnum;
    759764              else if (strcmp(name,"SedimentHead")==0) return SedimentHeadEnum;
    760765              else if (strcmp(name,"SedimentHeadOld")==0) return SedimentHeadOldEnum;
    … …  
    864869              else if (strcmp(name,"SmbZTop")==0) return SmbZTopEnum;
    865870              else if (strcmp(name,"SmbZY")==0) return SmbZYEnum;
     871              else if (strcmp(name,"SolidearthExternalDisplacementEastRate")==0) return SolidearthExternalDisplacementEastRateEnum;
     872              else if (strcmp(name,"SolidearthExternalDisplacementNorthRate")==0) return SolidearthExternalDisplacementNorthRateEnum;
     873              else if (strcmp(name,"SolidearthExternalDisplacementUpRate")==0) return SolidearthExternalDisplacementUpRateEnum;
     874              else if (strcmp(name,"SolidearthExternalGeoidRate")==0) return SolidearthExternalGeoidRateEnum;
     875              else if (strcmp(name,"SolidearthExternalBarystaticSeaLevelRate")==0) return SolidearthExternalBarystaticSeaLevelRateEnum;
    866876              else if (strcmp(name,"StrainRateeffective")==0) return StrainRateeffectiveEnum;
    867               else if (strcmp(name,"StrainRateparallel")==0) return StrainRateparallelEnum;
     877         else stage=8;
     878   }
     879   if(stage==8){
     880              if (strcmp(name,"StrainRateparallel")==0) return StrainRateparallelEnum;
    868881              else if (strcmp(name,"StrainRateperpendicular")==0) return StrainRateperpendicularEnum;
    869882              else if (strcmp(name,"StrainRatexx")==0) return StrainRatexxEnum;
    … …  
    875888              else if (strcmp(name,"StressMaxPrincipal")==0) return StressMaxPrincipalEnum;
    876889              else if (strcmp(name,"StressTensorxx")==0) return StressTensorxxEnum;
    877          else stage=8;
    878    }
    879    if(stage==8){
    880               if (strcmp(name,"StressTensorxy")==0) return StressTensorxyEnum;
     890              else if (strcmp(name,"StressTensorxy")==0) return StressTensorxyEnum;
    881891              else if (strcmp(name,"StressTensorxz")==0) return StressTensorxzEnum;
    882892              else if (strcmp(name,"StressTensoryy")==0) return StressTensoryyEnum;
    … …  
    988998              else if (strcmp(name,"Outputdefinition5")==0) return Outputdefinition5Enum;
    989999              else if (strcmp(name,"Outputdefinition60")==0) return Outputdefinition60Enum;
    990               else if (strcmp(name,"Outputdefinition61")==0) return Outputdefinition61Enum;
     1000         else stage=9;
     1001   }
     1002   if(stage==9){
     1003              if (strcmp(name,"Outputdefinition61")==0) return Outputdefinition61Enum;
    9911004              else if (strcmp(name,"Outputdefinition62")==0) return Outputdefinition62Enum;
    9921005              else if (strcmp(name,"Outputdefinition63")==0) return Outputdefinition63Enum;
    … …  
    9981011              else if (strcmp(name,"Outputdefinition69")==0) return Outputdefinition69Enum;
    9991012              else if (strcmp(name,"Outputdefinition6")==0) return Outputdefinition6Enum;
    1000          else stage=9;
    1001    }
    1002    if(stage==9){
    1003               if (strcmp(name,"Outputdefinition70")==0) return Outputdefinition70Enum;
     1013              else if (strcmp(name,"Outputdefinition70")==0) return Outputdefinition70Enum;
    10041014              else if (strcmp(name,"Outputdefinition71")==0) return Outputdefinition71Enum;
    10051015              else if (strcmp(name,"Outputdefinition72")==0) return Outputdefinition72Enum;
    … …  
    11111121              else if (strcmp(name,"DoubleMatExternalResult")==0) return DoubleMatExternalResultEnum;
    11121122              else if (strcmp(name,"DoubleMatParam")==0) return DoubleMatParamEnum;
    1113               else if (strcmp(name,"DoubleParam")==0) return DoubleParamEnum;
     1123         else stage=10;
     1124   }
     1125   if(stage==10){
     1126              if (strcmp(name,"DoubleParam")==0) return DoubleParamEnum;
    11141127              else if (strcmp(name,"DoubleVecParam")==0) return DoubleVecParamEnum;
    11151128              else if (strcmp(name,"Element")==0) return ElementEnum;
    … …  
    11211134              else if (strcmp(name,"EsaTransitions")==0) return EsaTransitionsEnum;
    11221135              else if (strcmp(name,"ExternalResult")==0) return ExternalResultEnum;
    1123          else stage=10;
    1124    }
    1125    if(stage==10){
    1126               if (strcmp(name,"ExtrapolationAnalysis")==0) return ExtrapolationAnalysisEnum;
     1136              else if (strcmp(name,"ExtrapolationAnalysis")==0) return ExtrapolationAnalysisEnum;
    11271137              else if (strcmp(name,"ExtrudeFromBaseAnalysis")==0) return ExtrudeFromBaseAnalysisEnum;
    11281138              else if (strcmp(name,"ExtrudeFromTopAnalysis")==0) return ExtrudeFromTopAnalysisEnum;
    … …  
    12341244              else if (strcmp(name,"Matenhancedice")==0) return MatenhancediceEnum;
    12351245              else if (strcmp(name,"Materials")==0) return MaterialsEnum;
    1236               else if (strcmp(name,"Matestar")==0) return MatestarEnum;
     1246         else stage=11;
     1247   }
     1248   if(stage==11){
     1249              if (strcmp(name,"Matestar")==0) return MatestarEnum;
    12371250              else if (strcmp(name,"Matice")==0) return MaticeEnum;
    12381251              else if (strcmp(name,"Matlitho")==0) return MatlithoEnum;
    … …  
    12441257              else if (strcmp(name,"MaxDivergence")==0) return MaxDivergenceEnum;
    12451258              else if (strcmp(name,"MaxVel")==0) return MaxVelEnum;
    1246          else stage=11;
    1247    }
    1248    if(stage==11){
    1249               if (strcmp(name,"MaxVx")==0) return MaxVxEnum;
     1259              else if (strcmp(name,"MaxVx")==0) return MaxVxEnum;
    12501260              else if (strcmp(name,"MaxVy")==0) return MaxVyEnum;
    12511261              else if (strcmp(name,"MaxVz")==0) return MaxVzEnum;
    … …  
    13351345              else if (strcmp(name,"SealevelNmotion")==0) return SealevelNmotionEnum;
    13361346              else if (strcmp(name,"SealevelUmotion")==0) return SealevelUmotionEnum;
    1337               else if (strcmp(name,"SealevelriseAnalysis")==0) return SealevelriseAnalysisEnum;
    1338               else if (strcmp(name,"SealevelriseSolution")==0) return SealevelriseSolutionEnum;
     1347              else if (strcmp(name,"SealevelchangeAnalysis")==0) return SealevelchangeAnalysisEnum;
     1348              else if (strcmp(name,"SealevelchangeSolution")==0) return SealevelchangeSolutionEnum;
    13391349              else if (strcmp(name,"Seg")==0) return SegEnum;
    13401350              else if (strcmp(name,"SegInput")==0) return SegInputEnum;
    … …  
    13571367              else if (strcmp(name,"StressbalanceAnalysis")==0) return StressbalanceAnalysisEnum;
    13581368              else if (strcmp(name,"StressbalanceConvergenceNumSteps")==0) return StressbalanceConvergenceNumStepsEnum;
    1359               else if (strcmp(name,"StressbalanceSIAAnalysis")==0) return StressbalanceSIAAnalysisEnum;
     1369         else stage=12;
     1370   }
     1371   if(stage==12){
     1372              if (strcmp(name,"StressbalanceSIAAnalysis")==0) return StressbalanceSIAAnalysisEnum;
    13601373              else if (strcmp(name,"StressbalanceSolution")==0) return StressbalanceSolutionEnum;
    13611374              else if (strcmp(name,"StressbalanceVerticalAnalysis")==0) return StressbalanceVerticalAnalysisEnum;
    … …  
    13671380              else if (strcmp(name,"SubelementMelt1")==0) return SubelementMelt1Enum;
    13681381              else if (strcmp(name,"SubelementMelt2")==0) return SubelementMelt2Enum;
    1369          else stage=12;
    1370    }
    1371    if(stage==12){
    1372               if (strcmp(name,"SubelementMigration")==0) return SubelementMigrationEnum;
     1382              else if (strcmp(name,"SubelementMigration")==0) return SubelementMigrationEnum;
    13731383              else if (strcmp(name,"SurfaceSlopeSolution")==0) return SurfaceSlopeSolutionEnum;
    13741384              else if (strcmp(name,"TaylorHood")==0) return TaylorHoodEnum;

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

    r25767 r25947  
    4141                        self.partitionhydro=[];
    4242
    43                         %no external solutions by defalt:
     43                        %no external solutions by default:
    4444                        self.external=[];
    4545
    … …  
    120120                        self.rotational.marshall(prefix,md,fid);
    121121                        if ~isempty(self.external),
     122                                WriteData(fid,prefix,'data',1,'format','Integer','name','md.solidearth.isexternal');
    122123                                self.external.marshall(prefix,md,fid);
     124                        else
     125                                WriteData(fid,prefix,'data',0,'format','Integer','name','md.solidearth.isexternal');
    123126                        end
    124127                       

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

    r25763 r25947  
    4040                end % }}}
    4141                function disp(self) % {{{
    42                         fielddisplay(self,'displacementeast','solid-Earth Eastwards bedrock motion (m/yr)');
    43                         fielddisplay(self,'displacementnorth','solid-Earth Northwards bedrock motion (m/yr)');
    44                         fielddisplay(self,'displacementup','solid-Earth bedrock uplift rate (m/yr)');
    45                         fielddisplay(self,'geoid','solid-Earth geoid motion (m/yr)');
    46                         fielddisplay(self,'barystaticsealevel','barystatic absolute sea-level rate (m/yr)');
     42                        disp(sprintf('%s','         units for time series is (yr)'));
     43                        fielddisplay(self,'displacementeast','solid-Earth Eastwards bedrock displacement series (m)');
     44                        fielddisplay(self,'displacementnorth','solid-Earth Northwards bedrock displacement time series (m)');
     45                        fielddisplay(self,'displacementup','solid-Earth bedrock uplift time series (m)');
     46                        fielddisplay(self,'geoid','solid-Earth geoid time series (m)');
     47                        fielddisplay(self,'barystaticsealevel','barystatic absolute sea-level time series (m)');
    4748
    4849                end % }}}
    4950                function marshall(self,prefix,md,fid) % {{{
    5051                        yts=md.constants.yts;
    51                         WriteData(fid,prefix,'object',self,'class','solidearthsolution','fieldname','displacementeast','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1,'yts',md.constants.yts);
    52                         WriteData(fid,prefix,'object',self,'class','solidearthsolution','fieldname','displacementnorth','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1,'yts',md.constants.yts);
    53                         WriteData(fid,prefix,'object',self,'class','solidearthsolution','fieldname','displacementup','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1,'yts',md.constants.yts);
    54                         WriteData(fid,prefix,'object',self,'class','solidearthsolution','fieldname','geoid','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1,'yts',md.constants.yts);
    55                         WriteData(fid,prefix,'object',self,'class','solidearthsolution','fieldname','barystaticsealevel','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1,'yts',md.constants.yts);
     52
     53                        %transform our time series into time series rates
     54                        time=self.displacementeast(end,:);
     55                        dt=diff(time,1,2);
     56                       
     57                        displacementeast_rate=diff(displacementeast(1:end-1,:),1,2)./dt;
     58                        displacementnorth_rate=diff(displacementnorth(1:end-1,:),1,2)./dt;
     59                        displacementup_rate=diff(displacementup(1:end-1,:),1,2)./dt;
     60                        geoid_rate=diff(geoid(1:end-1,:),1,2)./dt;
     61                        barystaticsealevel_rate=diff(barystaticsealevel(1:end-1,:),1,2)./dt;
     62
     63                        WriteData(fid,prefix,'name','md.solidearth.external.displacementeast','data',displacementeast_rate,'format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1,'yts',md.constants.yts);
     64                        WriteData(fid,prefix,'name','md.solidearth.external.displacementup','data',displacementup_rate,'format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1,'yts',md.constants.yts);
     65                        WriteData(fid,prefix,'name','md.solidearth.external.displacementnorth','data',displacementnorth_rate,'format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1,'yts',md.constants.yts);
     66                        WriteData(fid,prefix,'name','md.solidearth.external.geoid','data',geoid_rate,'format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1,'yts',md.constants.yts);
     67                        WriteData(fid,prefix,'name','md.solidearth.external.barystaticsealevel','data',barystaticsealevel_rate,'format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1,'yts',md.constants.yts);
    5668       
    5769                end % }}}
Note: See TracChangeset for help on using the changeset viewer.