Changeset 20459


Ignore:
Timestamp:
04/07/16 13:17:53 (9 years ago)
Author:
seroussi
Message:

CHG: remove md.transient.islevelset field

Location:
issm/trunk-jpl
Files:
1 deleted
35 edited

Legend:

Unmodified
Added
Removed

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

    r20453 r20459  
    4343
    4444        int finiteelement;
    45         bool   islevelset;
     45        bool   ismovingfront;
    4646
    4747        iomodel->Constant(&finiteelement,DamageElementinterpEnum);
    48         iomodel->Constant(&islevelset,TransientIslevelsetEnum);
     48        iomodel->Constant(&ismovingfront,TransientIsmovingfrontEnum);
    4949
    5050        /*Update elements: */

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

    r20453 r20459  
    107107void EnthalpyAnalysis::UpdateElements(Elements* elements,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/
    108108
    109         bool dakota_analysis,islevelset,isenthalpy;
     109        bool dakota_analysis,ismovingfront,isenthalpy;
    110110        int frictionlaw,basalforcing_model;
    111111        int FrictionCoupling;
    … …  
    132132
    133133        iomodel->Constant(&dakota_analysis,QmuIsdakotaEnum);
    134         iomodel->Constant(&islevelset,TransientIslevelsetEnum);
     134        iomodel->Constant(&ismovingfront,TransientIsmovingfrontEnum);
    135135        iomodel->Constant(&frictionlaw,FrictionLawEnum);
    136136
    … …  
    159159        InputUpdateFromConstantx(elements,0.,VyMeshEnum);
    160160        InputUpdateFromConstantx(elements,0.,VzMeshEnum);
    161         if(islevelset){
     161        if(ismovingfront){
    162162                iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum); // required for updating active nodes
    163163        }

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

    r20452 r20459  
    4949
    5050        /*Get moving front parameters*/
    51         bool ismovingfront;
    5251        int  calvinglaw;
    53         iomodel->Constant(&ismovingfront,TransientIsmovingfrontEnum);
    54         if(ismovingfront){
    55                 iomodel->Constant(&calvinglaw,CalvingLawEnum);
    56                 iomodel->Constant(&ismovingfront,TransientIsmovingfrontEnum);
    57                 switch(calvinglaw){
    58                         case DefaultCalvingEnum:
    59                                 iomodel->FetchDataToInput(elements,CalvingCalvingrateEnum);
    60                                 iomodel->FetchDataToInput(elements,CalvingMeltingrateEnum);
    61                                 break;
    62                         case CalvingLevermannEnum:
    63                                 iomodel->FetchDataToInput(elements,CalvinglevermannCoeffEnum);
    64                                 iomodel->FetchDataToInput(elements,CalvinglevermannMeltingrateEnum);
    65                                 break;
    66                         case CalvingPiEnum:
    67                                 iomodel->FetchDataToInput(elements,CalvingpiCoeffEnum);
    68                                 iomodel->FetchDataToInput(elements,CalvingpiMeltingrateEnum);
    69                                 break;
    70                         case CalvingDevEnum:
    71                                 iomodel->FetchDataToInput(elements,CalvingpiCoeffEnum);
    72                                 iomodel->FetchDataToInput(elements,CalvingMeltingrateEnum);
    73                                 break;
    74                         default:
    75                                 _error_("Calving law "<<EnumToStringx(calvinglaw)<<" not supported yet");
    76                 }
     52        iomodel->Constant(&calvinglaw,CalvingLawEnum);
     53        switch(calvinglaw){
     54                case DefaultCalvingEnum:
     55                        iomodel->FetchDataToInput(elements,CalvingCalvingrateEnum);
     56                        iomodel->FetchDataToInput(elements,CalvingMeltingrateEnum);
     57                        break;
     58                case CalvingLevermannEnum:
     59                        iomodel->FetchDataToInput(elements,CalvinglevermannCoeffEnum);
     60                        iomodel->FetchDataToInput(elements,CalvinglevermannMeltingrateEnum);
     61                        break;
     62                case CalvingPiEnum:
     63                        iomodel->FetchDataToInput(elements,CalvingpiCoeffEnum);
     64                        iomodel->FetchDataToInput(elements,CalvingpiMeltingrateEnum);
     65                        break;
     66                case CalvingDevEnum:
     67                        iomodel->FetchDataToInput(elements,CalvingpiCoeffEnum);
     68                        iomodel->FetchDataToInput(elements,CalvingMeltingrateEnum);
     69                        break;
     70                default:
     71                        _error_("Calving law "<<EnumToStringx(calvinglaw)<<" not supported yet");
    7772        }
    7873}
    … …  
    129124        /*Intermediaries */
    130125        int  stabilization,dim, domaintype, calvinglaw;
    131         bool ismovingfront;
    132126        int i, row, col;
    133127        IssmDouble kappa;
    … …  
    139133
    140134        /*Get problem dimension and whether there is moving front or not*/
    141         basalelement->FindParam(&ismovingfront,TransientIsmovingfrontEnum);
    142135        basalelement->FindParam(&domaintype,DomainTypeEnum);
    143136        basalelement->FindParam(&calvinglaw,CalvingLawEnum);
    … …  
    194187
    195188        /*Load calving inputs*/
    196         if(ismovingfront){
    197                 switch(calvinglaw){
    198                         case DefaultCalvingEnum:
    199                         case CalvingDevEnum:
    200                                 lsf_slopex_input  = basalelement->GetInput(LevelsetfunctionSlopeXEnum); _assert_(lsf_slopex_input);
    201                                 if(dim==2) lsf_slopey_input  = basalelement->GetInput(LevelsetfunctionSlopeYEnum); _assert_(lsf_slopey_input);
    202                                 calvingrate_input = basalelement->GetInput(CalvingCalvingrateEnum);     _assert_(calvingrate_input);
    203                                 meltingrate_input = basalelement->GetInput(CalvingMeltingrateEnum);     _assert_(meltingrate_input);
    204                                 break;
    205                         case CalvingLevermannEnum:
    206                                 switch(domaintype){
    207                                         case Domain2DverticalEnum:
    208                                                 calvingratex_input=basalelement->GetInput(CalvingratexEnum); _assert_(calvingratex_input);
    209                                                 break;
    210                                         case Domain2DhorizontalEnum:
    211                                                 calvingratex_input=basalelement->GetInput(CalvingratexEnum); _assert_(calvingratex_input);
    212                                                 calvingratey_input=basalelement->GetInput(CalvingrateyEnum); _assert_(calvingratey_input);
    213                                                 break;
    214                                         case Domain3DEnum:
    215                                                 calvingratex_input=basalelement->GetInput(CalvingratexAverageEnum); _assert_(calvingratex_input);
    216                                                 calvingratey_input=basalelement->GetInput(CalvingrateyAverageEnum); _assert_(calvingratey_input);
    217                                                 break;
    218                                         default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    219                                 }
    220                                 meltingrate_input = basalelement->GetInput(CalvinglevermannMeltingrateEnum);     _assert_(meltingrate_input);
    221                                 break;
    222                         case CalvingPiEnum:
    223                                 switch(domaintype){
    224                                         case Domain2DverticalEnum:
    225                                                 calvingratex_input=basalelement->GetInput(CalvingratexEnum); _assert_(calvingratex_input);
    226                                                 break;
    227                                         case Domain2DhorizontalEnum:
    228                                                 calvingratex_input=basalelement->GetInput(CalvingratexEnum); _assert_(calvingratex_input);
    229                                                 calvingratey_input=basalelement->GetInput(CalvingrateyEnum); _assert_(calvingratey_input);
    230                                                 break;
    231                                         case Domain3DEnum:
    232                                                 calvingratex_input=basalelement->GetInput(CalvingratexAverageEnum); _assert_(calvingratex_input);
    233                                                 calvingratey_input=basalelement->GetInput(CalvingrateyAverageEnum); _assert_(calvingratey_input);
    234                                                 break;
    235                                         default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
    236                                 }
    237                                 meltingrate_input = basalelement->GetInput(CalvingpiMeltingrateEnum);     _assert_(meltingrate_input);
    238                                 break;
    239                         default:
    240                                 _error_("Calving law "<<EnumToStringx(calvinglaw)<<" not supported yet");
    241                 }
     189        switch(calvinglaw){
     190                case DefaultCalvingEnum:
     191                case CalvingDevEnum:
     192                        lsf_slopex_input  = basalelement->GetInput(LevelsetfunctionSlopeXEnum); _assert_(lsf_slopex_input);
     193                        if(dim==2) lsf_slopey_input  = basalelement->GetInput(LevelsetfunctionSlopeYEnum); _assert_(lsf_slopey_input);
     194                        calvingrate_input = basalelement->GetInput(CalvingCalvingrateEnum);     _assert_(calvingrate_input);
     195                        meltingrate_input = basalelement->GetInput(CalvingMeltingrateEnum);     _assert_(meltingrate_input);
     196                        break;
     197                case CalvingLevermannEnum:
     198                        switch(domaintype){
     199                                case Domain2DverticalEnum:
     200                                        calvingratex_input=basalelement->GetInput(CalvingratexEnum); _assert_(calvingratex_input);
     201                                        break;
     202                                case Domain2DhorizontalEnum:
     203                                        calvingratex_input=basalelement->GetInput(CalvingratexEnum); _assert_(calvingratex_input);
     204                                        calvingratey_input=basalelement->GetInput(CalvingrateyEnum); _assert_(calvingratey_input);
     205                                        break;
     206                                case Domain3DEnum:
     207                                        calvingratex_input=basalelement->GetInput(CalvingratexAverageEnum); _assert_(calvingratex_input);
     208                                        calvingratey_input=basalelement->GetInput(CalvingrateyAverageEnum); _assert_(calvingratey_input);
     209                                        break;
     210                                default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
     211                        }
     212                        meltingrate_input = basalelement->GetInput(CalvinglevermannMeltingrateEnum);     _assert_(meltingrate_input);
     213                        break;
     214                case CalvingPiEnum:
     215                        switch(domaintype){
     216                                case Domain2DverticalEnum:
     217                                        calvingratex_input=basalelement->GetInput(CalvingratexEnum); _assert_(calvingratex_input);
     218                                        break;
     219                                case Domain2DhorizontalEnum:
     220                                        calvingratex_input=basalelement->GetInput(CalvingratexEnum); _assert_(calvingratex_input);
     221                                        calvingratey_input=basalelement->GetInput(CalvingrateyEnum); _assert_(calvingratey_input);
     222                                        break;
     223                                case Domain3DEnum:
     224                                        calvingratex_input=basalelement->GetInput(CalvingratexAverageEnum); _assert_(calvingratex_input);
     225                                        calvingratey_input=basalelement->GetInput(CalvingrateyAverageEnum); _assert_(calvingratey_input);
     226                                        break;
     227                                default: _error_("mesh "<<EnumToStringx(domaintype)<<" not supported yet");
     228                        }
     229                        meltingrate_input = basalelement->GetInput(CalvingpiMeltingrateEnum);     _assert_(meltingrate_input);
     230                        break;
     231                default:
     232                        _error_("Calving law "<<EnumToStringx(calvinglaw)<<" not supported yet");
    242233        }
    243234
    … …  
    267258
    268259                /*Get calving speed*/
    269                 if(ismovingfront){
    270                         switch(calvinglaw){
    271                                 case DefaultCalvingEnum:
    272                                         lsf_slopex_input->GetInputValue(&dlsf[0],gauss);
    273                                         if(dim==2) lsf_slopey_input->GetInputValue(&dlsf[1],gauss);
    274                                         calvingrate_input->GetInputValue(&calvingrate,gauss);
    275                                         meltingrate_input->GetInputValue(&meltingrate,gauss);
    276 
    277                                         norm_dlsf=0.;
    278                                         for(i=0;i<dim;i++) norm_dlsf+=pow(dlsf[i],2);
    279                                         norm_dlsf=sqrt(norm_dlsf);
    280 
    281                                         if(norm_dlsf>1.e-10)
    282                                          for(i=0;i<dim;i++){
    283                                           c[i]=calvingrate*dlsf[i]/norm_dlsf; m[i]=meltingrate*dlsf[i]/norm_dlsf;
    284                                          }
    285                                         else
    286                                          for(i=0;i<dim;i++){
    287                                                  c[i]=0.; m[i]=0.;
    288                                          }
    289                                         break;
    290 
    291                                 case CalvingLevermannEnum:
    292                                 case CalvingPiEnum:
    293                                 case CalvingDevEnum:
    294                                         calvingratex_input->GetInputValue(&c[0],gauss);
    295                                         if(dim==2) calvingratey_input->GetInputValue(&c[1],gauss);
    296                                         meltingrate_input->GetInputValue(&meltingrate,gauss);
    297                                         norm_calving=0.;
    298                                         for(i=0;i<dim;i++) norm_calving+=pow(c[i],2);
    299                                         norm_calving=sqrt(norm_calving)+1.e-14;
    300                                         for(i=0;i<dim;i++) m[i]=meltingrate*c[i]/norm_calving;
    301                                         break;
    302 
    303                                 default:
    304                                         _error_("Calving law "<<EnumToStringx(calvinglaw)<<" not supported yet");
    305                         }
     260                switch(calvinglaw){
     261                        case DefaultCalvingEnum:
     262                                lsf_slopex_input->GetInputValue(&dlsf[0],gauss);
     263                                if(dim==2) lsf_slopey_input->GetInputValue(&dlsf[1],gauss);
     264                                calvingrate_input->GetInputValue(&calvingrate,gauss);
     265                                meltingrate_input->GetInputValue(&meltingrate,gauss);
     266
     267                                norm_dlsf=0.;
     268                                for(i=0;i<dim;i++) norm_dlsf+=pow(dlsf[i],2);
     269                                norm_dlsf=sqrt(norm_dlsf);
     270
     271                                if(norm_dlsf>1.e-10)
     272                                 for(i=0;i<dim;i++){
     273                                         c[i]=calvingrate*dlsf[i]/norm_dlsf; m[i]=meltingrate*dlsf[i]/norm_dlsf;
     274                                 }
     275                                else
     276                                 for(i=0;i<dim;i++){
     277                                         c[i]=0.; m[i]=0.;
     278                                 }
     279                                break;
     280
     281                        case CalvingLevermannEnum:
     282                        case CalvingPiEnum:
     283                        case CalvingDevEnum:
     284                                calvingratex_input->GetInputValue(&c[0],gauss);
     285                                if(dim==2) calvingratey_input->GetInputValue(&c[1],gauss);
     286                                meltingrate_input->GetInputValue(&meltingrate,gauss);
     287                                norm_calving=0.;
     288                                for(i=0;i<dim;i++) norm_calving+=pow(c[i],2);
     289                                norm_calving=sqrt(norm_calving)+1.e-14;
     290                                for(i=0;i<dim;i++) m[i]=meltingrate*c[i]/norm_calving;
     291                                break;
     292
     293                        default:
     294                                _error_("Calving law "<<EnumToStringx(calvinglaw)<<" not supported yet");
    306295                }
    307296

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

    r20453 r20459  
    121121        bool   dakota_analysis;
    122122        bool   isgroundingline;
    123         bool   islevelset;
     123        bool   ismovingfront;
    124124
    125125        /*Fetch data needed: */
    … …  
    127127        iomodel->Constant(&dakota_analysis,QmuIsdakotaEnum);
    128128        iomodel->Constant(&isgroundingline,TransientIsgroundinglineEnum);
    129         iomodel->Constant(&islevelset,TransientIslevelsetEnum);
     129        iomodel->Constant(&ismovingfront,TransientIsmovingfrontEnum);
    130130
    131131        /*Finite element type*/

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

    r20457 r20459  
    678678        bool   control_analysis;
    679679        bool   dakota_analysis;
    680         bool   islevelset;
     680        bool   ismovingfront;
    681681        bool   isdamage;
    682682
    … …  
    689689        iomodel->Constant(&dakota_analysis,QmuIsdakotaEnum);
    690690        iomodel->Constant(&materials_type,MaterialsEnum);
    691         iomodel->Constant(&islevelset,TransientIslevelsetEnum);
     691        iomodel->Constant(&ismovingfront,TransientIsmovingfrontEnum);
    692692        iomodel->Constant(&frictionlaw,FrictionLawEnum);
    693693

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

    r20453 r20459  
    122122        /*Fetch data needed: */
    123123        bool   isSIA;
    124         bool   islevelset;
     124        bool   ismovingfront;
    125125        int    frictionlaw;
    126126        iomodel->Constant(&isSIA,FlowequationIsSIAEnum);
    127         iomodel->Constant(&islevelset,TransientIslevelsetEnum);
     127        iomodel->Constant(&ismovingfront,TransientIsmovingfrontEnum);
    128128        iomodel->Constant(&frictionlaw,FrictionLawEnum);
    129129
    … …  
    166166        iomodel->FetchDataToInput(elements,ThicknessEnum);
    167167        iomodel->FetchDataToInput(elements,MaskGroundediceLevelsetEnum);
    168         if(islevelset){
     168        if(ismovingfront){
    169169                if(iomodel->domaintype!=Domain2DhorizontalEnum)
    170170                        iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum); // required for updating active nodes

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

    r20453 r20459  
    8989        }
    9090
    91         bool dakota_analysis, islevelset;
     91        bool dakota_analysis, ismovingfront;
    9292        iomodel->Constant(&dakota_analysis,QmuIsdakotaEnum);
    93         iomodel->Constant(&islevelset,TransientIslevelsetEnum);
     93        iomodel->Constant(&ismovingfront,TransientIsmovingfrontEnum);
    9494        iomodel->Constant(&frictionlaw,FrictionLawEnum);
    9595
    … …  
    116116        InputUpdateFromConstantx(elements,0.,VyMeshEnum);
    117117        InputUpdateFromConstantx(elements,0.,VzMeshEnum);
    118         if(islevelset){
     118        if(ismovingfront){
    119119                iomodel->FetchDataToInput(elements,MeshVertexonbaseEnum); // required for updating active nodes
    120120        }

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

    r20453 r20459  
    546546
    547547                case TransientSolutionEnum:{
    548                         bool isSIA,isFS,isthermal,isenthalpy,ismasstransport,isgroundingline,isstressbalance,islevelset,ishydrology,isdamage,issmb,isslr;
     548                        bool isSIA,isFS,isthermal,isenthalpy,ismasstransport,isgroundingline,isstressbalance,ismovingfront,ishydrology,isdamage,issmb,isslr;
    549549                        iomodel->Constant(&isSIA,FlowequationIsSIAEnum);
    550550                        iomodel->Constant(&isFS,FlowequationIsFSEnum);
    551551                        iomodel->Constant(&isthermal,TransientIsthermalEnum);
    552552                        iomodel->Constant(&isenthalpy,ThermalIsenthalpyEnum);
    553                         iomodel->Constant(&islevelset,TransientIslevelsetEnum);
     553                        iomodel->Constant(&ismovingfront,TransientIsmovingfrontEnum);
    554554                        iomodel->Constant(&ismasstransport,TransientIsmasstransportEnum);
    555555                        iomodel->Constant(&isstressbalance,TransientIsstressbalanceEnum);
    … …  
    585585                        }
    586586                        if(issmb) analyses_temp[numanalyses++]=SmbAnalysisEnum;
    587                         if(islevelset){
     587                        if(ismovingfront){
    588588                                analyses_temp[numanalyses++]=LevelsetAnalysisEnum;
    589589                                analyses_temp[numanalyses++]=ExtrapolationAnalysisEnum;

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

    r20454 r20459  
    2424        femmodel->parameters->FindParam(&ismasstransport,TransientIsmasstransportEnum);
    2525        femmodel->parameters->FindParam(&isthermal,TransientIsthermalEnum);
    26         femmodel->parameters->FindParam(&islevelset,TransientIslevelsetEnum);
    2726        femmodel->parameters->FindParam(&ismovingfront,TransientIsmovingfrontEnum);
    2827        if(isthermal && domaintype==Domain3DEnum) femmodel->parameters->FindParam(&isenthalpy,ThermalIsenthalpyEnum);
    2928
    30         if(!islevelset) return;
     29        if(!ismovingfront) return;
    3130
    3231        /* start the work from here */
    33         if(ismovingfront) Calvingx(femmodel);
     32        Calvingx(femmodel);
    3433        if(VerboseSolution()) _printf0_("   computing levelset transport\n");
    3534        /* smoothen slope of lsf for computation of normal on ice domain*/

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

    r20454 r20459  
    2121        /*parameters: */
    2222        IssmDouble starttime,finaltime,dt,yts;
    23         bool       isstressbalance,ismasstransport,issmb,isFS,isthermal,isgroundingline,isgia,isslr,iscoupler,islevelset,isdamageevolution,ishydrology,ismovingfront;
     23        bool       isstressbalance,ismasstransport,issmb,isFS,isthermal,isgroundingline,isgia,isslr,iscoupler,ismovingfront,isdamageevolution,ishydrology;
    2424        bool       save_results,dakota_analysis;
    2525        bool       time_adapt;
    … …  
    5454        femmodel->parameters->FindParam(&iscoupler,TransientIscouplerEnum);
    5555        femmodel->parameters->FindParam(&isgroundingline,TransientIsgroundinglineEnum);
    56         femmodel->parameters->FindParam(&islevelset,TransientIslevelsetEnum);
     56        femmodel->parameters->FindParam(&ismovingfront,TransientIsmovingfrontEnum);
    5757        femmodel->parameters->FindParam(&isdamageevolution,TransientIsdamageevolutionEnum);
    5858        femmodel->parameters->FindParam(&ishydrology,TransientIshydrologyEnum);
    5959        femmodel->parameters->FindParam(&isFS,FlowequationIsFSEnum);
    60         femmodel->parameters->FindParam(&ismovingfront,TransientIsmovingfrontEnum);
    6160        if(isgroundingline) femmodel->parameters->FindParam(&groundingline_migration,GroundinglineMigrationEnum);
    6261        femmodel->parameters->FindParam(&numoutputs,TransientNumRequestedOutputsEnum);
    … …  
    104103                if(isdamageevolution) damage_core(femmodel);
    105104
    106                 if(islevelset)  movingfront_core(femmodel);
     105                if(ismovingfront)       movingfront_core(femmodel);
    107106
    108107                /* from here on, prepare geometry for next time step*/

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

    r20452 r20459  
    8080                parameters->AddObject(iomodel->CopyConstantObject(TransientIsgroundinglineEnum));
    8181                parameters->AddObject(iomodel->CopyConstantObject(TransientIsgiaEnum));
    82                 parameters->AddObject(iomodel->CopyConstantObject(TransientIslevelsetEnum));
    8382                parameters->AddObject(iomodel->CopyConstantObject(TransientIsdamageevolutionEnum));
    8483                parameters->AddObject(iomodel->CopyConstantObject(TransientIshydrologyEnum));

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

    r20452 r20459  
    10431043        /*}}}*/
    10441044        /*Levelset related enums (will be moved to appropriate place when finished){{{*/
    1045         TransientIslevelsetEnum,
    10461045        SpcLevelsetEnum,
    10471046        ExtrapolationVariableEnum,

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

    r20452 r20459  
    997997                case ArrheniusEnum : return "Arrhenius";
    998998                case LliboutryDuvalEnum : return "LliboutryDuval";
    999                 case TransientIslevelsetEnum : return "TransientIslevelset";
    1000999                case SpcLevelsetEnum : return "SpcLevelset";
    10011000                case ExtrapolationVariableEnum : return "ExtrapolationVariable";

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

    r20452 r20459  
    10211021              else if (strcmp(name,"Arrhenius")==0) return ArrheniusEnum;
    10221022              else if (strcmp(name,"LliboutryDuval")==0) return LliboutryDuvalEnum;
    1023               else if (strcmp(name,"TransientIslevelset")==0) return TransientIslevelsetEnum;
    10241023              else if (strcmp(name,"SpcLevelset")==0) return SpcLevelsetEnum;
    10251024              else if (strcmp(name,"ExtrapolationVariable")==0) return ExtrapolationVariableEnum;

  • issm/trunk-jpl/src/m/classes/trans.js

    r20452 r20459  
    1616                this.isgia           = 0;
    1717                this.isdamageevolution = 0;
    18                 this.islevelset      = 0;
    1918                this.ismovingfront   = 0;
    2019                this.ishydrology     = 0;
    … …  
    3736                fielddisplay(this,'isgia','indicates whether a postglacial rebound model is used in the transient');
    3837                fielddisplay(this,'isdamageevolution','indicates whether damage evolution is used in the transient');
    39                 fielddisplay(this,'islevelset','LEVEL SET DESCRIPTION...');
    4038                fielddisplay(this,'ismovingfront','indicates whether a moving front capability is used in the transient');
    4139                fielddisplay(this,'ishydrology','indicates whether an hydrology model is used');
    … …  
    6159                        checkfield(md,'fieldname','trans.isgia','numel',[1],'values',[0, 1]);
    6260                        checkfield(md,'fieldname','trans.isdamageevolution','numel',[1],'values',[0, 1]);
    63                         checkfield(md,'fieldname','trans.islevelset','numel',[1],'values',[0, 1]);
    6461                        checkfield(md,'fieldname','trans.ismovingfront','numel',[1],'values',[0, 1]);
    6562                        checkfield(md,'fieldname','trans.ishydrology','numel',[1],'values',[0 ,1]);
    … …  
    7774                        WriteData(fid,'object',this,'fieldname','isdamageevolution','format','Boolean');
    7875                        WriteData(fid,'object',this,'fieldname','ishydrology','format','Boolean');
    79                         WriteData(fid,'object',this,'fieldname','islevelset','format','Boolean');
    8076                        WriteData(fid,'object',this,'fieldname','ismovingfront','format','Boolean');
    8177                        WriteData(fid,'object',this,'fieldname','isslr','format','Boolean');
    … …  
    109105        this.isgia             = 0;
    110106        this.isdamageevolution = 0;
    111         this.islevelset        = 0;
    112107        this.ismovingfront     = 0;
    113108        this.ishydrology       = 0;

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

    r20452 r20459  
    1313                isgia             = 0;
    1414                isdamageevolution = 0;
    15                 islevelset        = 0;
    1615                ismovingfront     = 0;
    1716                ishydrology       = 0;
    … …  
    3938                        self.isgia           = 0;
    4039                        self.isdamageevolution = 0;
    41                         self.islevelset      = 0;
    4240                        self.ismovingfront   =0;
    4341                        self.ishydrology     = 0;
    … …  
    5856                        self.isgia           = 0;
    5957                        self.isdamageevolution = 0;
    60                         self.islevelset      = 0;
    6158                        self.ismovingfront   = 0;
    6259                        self.ishydrology     = 0;
    … …  
    8683                        md = checkfield(md,'fieldname','transient.isgia','numel',[1],'values',[0 1]);
    8784                        md = checkfield(md,'fieldname','transient.isdamageevolution','numel',[1],'values',[0 1]);
    88                         md = checkfield(md,'fieldname','transient.islevelset','numel',[1],'values',[0 1]);
    8985                        md = checkfield(md,'fieldname','transient.ismovingfront','numel',[1],'values',[0 1]);
    9086                        md = checkfield(md,'fieldname','transient.ishydrology','numel',[1],'values',[0 1]);
    … …  
    104100                        fielddisplay(self,'isgia','indicates whether a postglacial rebound model is used in the transient');
    105101                        fielddisplay(self,'isdamageevolution','indicates whether damage evolution is used in the transient');
    106                         fielddisplay(self,'islevelset','LEVEL SET DESCRIPTION...');
    107102                        fielddisplay(self,'ismovingfront','indicates whether a moving front capability is used in the transient');
    108103                        fielddisplay(self,'ishydrology','indicates whether an hydrology model is used');
    … …  
    121116                        WriteData(fid,'object',self,'fieldname','isdamageevolution','format','Boolean');
    122117                        WriteData(fid,'object',self,'fieldname','ishydrology','format','Boolean');
    123                         WriteData(fid,'object',self,'fieldname','islevelset','format','Boolean');
    124118                        WriteData(fid,'object',self,'fieldname','ismovingfront','format','Boolean');
    125119                        WriteData(fid,'object',self,'fieldname','isslr','format','Boolean');
    … …  
    144138                        writejsdouble(fid,[modelname '.trans.isgia'],self.isgia);
    145139                        writejsdouble(fid,[modelname '.trans.isdamageevolution'],self.isdamageevolution);
    146                         writejsdouble(fid,[modelname '.trans.islevelset'],self.islevelset);
    147140                        writejsdouble(fid,[modelname '.trans.ismovingfront'],self.ismovingfront);
    148141                        writejsdouble(fid,[modelname '.trans.ishydrology'],self.ishydrology);

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

    r20452 r20459  
    2020                self.isgia             = False
    2121                self.isdamageevolution = False
    22                 self.islevelset        = False
    2322                self.ismovingfront     = False
    2423                self.ishydrology       = False
    … …  
    4039                string="%s\n%s"%(string,fielddisplay(self,'isgia','indicates if a postglacial rebound is used in the transient'))
    4140                string="%s\n%s"%(string,fielddisplay(self,'isdamageevolution','indicates whether damage evolution is used in the transient'))
    42                 string="%s\n%s"%(string,fielddisplay(self,'islevelset','LEVELSET METHOD DESCRIPTION'))
    4341                string="%s\n%s"%(string,fielddisplay(self,'ismovingfront','indicates whether a moving front capability is used in the transient'))
    4442                string="%s\n%s"%(string,fielddisplay(self,'ishydrology','indicates whether an hydrology model is used'))
    … …  
    6664                self.isgia             = False
    6765                self.isdamageevolution = False
    68                 self.islevelset        = False
    6966                self.ismovingfront     = False
    7067                self.ishydrology       = False
    … …  
    8683                self.isgia           = False
    8784                self.isdamageevolution = False
    88                 self.islevelset      = False
    8985                self.ismovingfront   = False
    9086                self.ishydrology     = False
    … …  
    109105                md = checkfield(md,'fieldname','transient.isgia','numel',[1],'values',[0,1])
    110106                md = checkfield(md,'fieldname','transient.isdamageevolution','numel',[1],'values',[0,1])
    111                 md = checkfield(md,'fieldname','transient.islevelset','numel',[1],'values',[0,1])
    112107                md = checkfield(md,'fieldname','transient.ishydrology','numel',[1],'values',[0,1])
    113108                md = checkfield(md,'fieldname','transient.ismovingfront','numel',[1],'values',[0,1]);
    … …  
    126121                WriteData(fid,'object',self,'fieldname','isgia','format','Boolean')
    127122                WriteData(fid,'object',self,'fieldname','isdamageevolution','format','Boolean')
    128                 WriteData(fid,'object',self,'fieldname','islevelset','format','Boolean')
    129123                WriteData(fid,'object',self,'fieldname','ishydrology','format','Boolean')
    130124                WriteData(fid,'object',self,'fieldname','ismovingfront','format','Boolean')

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

    r20452 r20459  
    982982function ArrheniusEnum(){ return 978;}
    983983function LliboutryDuvalEnum(){ return 979;}
    984 function TransientIslevelsetEnum(){ return 980;}
    985 function SpcLevelsetEnum(){ return 981;}
    986 function ExtrapolationVariableEnum(){ return 982;}
    987 function IceMaskNodeActivationEnum(){ return 983;}
    988 function LevelsetfunctionSlopeXEnum(){ return 984;}
    989 function LevelsetfunctionSlopeYEnum(){ return 985;}
    990 function LevelsetfunctionPicardEnum(){ return 986;}
    991 function SealevelriseSolutionEnum(){ return 987;}
    992 function SealevelriseAnalysisEnum(){ return 988;}
    993 function SealevelEnum(){ return 989;}
    994 function SealevelEustaticEnum(){ return 990;}
    995 function SealevelriseDeltathicknessEnum(){ return 991;}
    996 function SealevelriseMaxiterEnum(){ return 992;}
    997 function SealevelriseReltolEnum(){ return 993;}
    998 function SealevelriseAbstolEnum(){ return 994;}
    999 function SealevelriseLoveHEnum(){ return 995;}
    1000 function SealevelriseLoveKEnum(){ return 996;}
    1001 function SealevelriseTideLoveHEnum(){ return 997;}
    1002 function SealevelriseTideLoveKEnum(){ return 998;}
    1003 function SealevelriseRigidEnum(){ return 999;}
    1004 function SealevelriseElasticEnum(){ return 1000;}
    1005 function SealevelriseRotationEnum(){ return 1001;}
    1006 function SealevelriseGElasticEnum(){ return 1002;}
    1007 function SealevelriseDegaccEnum(){ return 1003;}
    1008 function SealevelriseTransitionsEnum(){ return 1004;}
    1009 function SealevelriseRequestedOutputsEnum(){ return 1005;}
    1010 function SealevelriseNumRequestedOutputsEnum(){ return 1006;}
    1011 function MaximumNumberOfDefinitionsEnum(){ return 1007;}
     984function SpcLevelsetEnum(){ return 980;}
     985function ExtrapolationVariableEnum(){ return 981;}
     986function IceMaskNodeActivationEnum(){ return 982;}
     987function LevelsetfunctionSlopeXEnum(){ return 983;}
     988function LevelsetfunctionSlopeYEnum(){ return 984;}
     989function LevelsetfunctionPicardEnum(){ return 985;}
     990function SealevelriseSolutionEnum(){ return 986;}
     991function SealevelriseAnalysisEnum(){ return 987;}
     992function SealevelEnum(){ return 988;}
     993function SealevelEustaticEnum(){ return 989;}
     994function SealevelriseDeltathicknessEnum(){ return 990;}
     995function SealevelriseMaxiterEnum(){ return 991;}
     996function SealevelriseReltolEnum(){ return 992;}
     997function SealevelriseAbstolEnum(){ return 993;}
     998function SealevelriseLoveHEnum(){ return 994;}
     999function SealevelriseLoveKEnum(){ return 995;}
     1000function SealevelriseTideLoveHEnum(){ return 996;}
     1001function SealevelriseTideLoveKEnum(){ return 997;}
     1002function SealevelriseRigidEnum(){ return 998;}
     1003function SealevelriseElasticEnum(){ return 999;}
     1004function SealevelriseRotationEnum(){ return 1000;}
     1005function SealevelriseGElasticEnum(){ return 1001;}
     1006function SealevelriseDegaccEnum(){ return 1002;}
     1007function SealevelriseTransitionsEnum(){ return 1003;}
     1008function SealevelriseRequestedOutputsEnum(){ return 1004;}
     1009function SealevelriseNumRequestedOutputsEnum(){ return 1005;}
     1010function MaximumNumberOfDefinitionsEnum(){ return 1006;}

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

    r20452 r20459  
    989989def ArrheniusEnum(): return StringToEnum("Arrhenius")[0]
    990990def LliboutryDuvalEnum(): return StringToEnum("LliboutryDuval")[0]
    991 def TransientIslevelsetEnum(): return StringToEnum("TransientIslevelset")[0]
    992991def SpcLevelsetEnum(): return StringToEnum("SpcLevelset")[0]
    993992def ExtrapolationVariableEnum(): return StringToEnum("ExtrapolationVariable")[0]

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

    r20452 r20459  
    88%Transient;
    99md.transient.isstressbalance=1;
    10 md.transient.islevelset=1;
    1110md.transient.ismovingfront=1;
    1211md.transient.ismasstransport=1;

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

    r20452 r20459  
    1818#Transient
    1919md.transient.isstressbalance=True
    20 md.transient.islevelset=True
    2120md.transient.ismovingfront=True
    2221md.transient.ismasstransport=True

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

    r20452 r20459  
    1313%Transient
    1414md.transient.isstressbalance=1;
    15 md.transient.islevelset=1;
    1615md.transient.ismovingfront=1;
    1716md.transient.ismasstransport=1;

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

    r20452 r20459  
    2323#Transient
    2424md.transient.isstressbalance=True
    25 md.transient.islevelset=True
    2625md.transient.ismovingfront=True
    2726md.transient.ismasstransport=True

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

    r20452 r20459  
    1515%Transient
    1616md.transient.isstressbalance=1;
    17 md.transient.islevelset=1;
    1817md.transient.ismovingfront=1;
    1918md.transient.ismasstransport=1;

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

    r20452 r20459  
    2525#Transient
    2626md.transient.isstressbalance=True
    27 md.transient.islevelset=True
    2827md.transient.ismovingfront=True
    2928md.transient.ismasstransport=True

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

    r20452 r20459  
    88%Transient
    99md.transient.isstressbalance=1;
    10 md.transient.islevelset=1;
    1110md.transient.ismasstransport=1;
    1211md.transient.issmb=1;

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

    r20452 r20459  
    1818#Transient
    1919md.transient.isstressbalance=True
    20 md.transient.islevelset=True
    2120md.transient.ismasstransport=True
    2221md.transient.issmb=True

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

    r20452 r20459  
    1515%Transient
    1616md.transient.isstressbalance=1;
    17 md.transient.islevelset=1;
    1817md.transient.ismasstransport=1;
    1918md.transient.issmb=1;

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

    r20452 r20459  
    2525#Transient
    2626md.transient.isstressbalance=True
    27 md.transient.islevelset=True
    2827md.transient.ismasstransport=True
    2928md.transient.issmb=True

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

    r20452 r20459  
    1818%Transient
    1919md.transient.isstressbalance=1;
    20 md.transient.islevelset=1;
    2120md.transient.ismasstransport=1;
    2221md.transient.issmb=1;

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

    r20452 r20459  
    2929#Transient
    3030md.transient.isstressbalance=True
    31 md.transient.islevelset=True
    3231md.transient.ismasstransport=True
    3332md.transient.issmb=True

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

    r20452 r20459  
    1818%Transient
    1919md.transient.isstressbalance=1;
    20 md.transient.islevelset=1;
    2120md.transient.ismasstransport=1;
    2221md.transient.issmb=1;

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

    r20452 r20459  
    2929#Transient
    3030md.transient.isstressbalance=True
    31 md.transient.islevelset=True
    3231md.transient.ismasstransport=True
    3332md.transient.issmb=True

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

    r19527 r20459  
    6161%Transient
    6262md.transient.isstressbalance = 1;
    63 md.transient.islevelset = 1;
     63md.transient.ismovingfront = 1;
    6464md.transient.ismasstransport = 0;
    6565md.transient.isthermal = 0;

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

    r19527 r20459  
    6868#Transient
    6969md.transient.isstressbalance=True
    70 md.transient.islevelset=True
     70md.transient.ismovingfront=True
    7171md.transient.ismasstransport=False
    7272md.transient.isthermal=False
Note: See TracChangeset for help on using the changeset viewer.