Changeset 25308


Ignore:
Timestamp:
07/29/20 02:53:58 (5 years ago)
Author:
bdef
Message:

CHG: pushing back change 25247

Location:
issm/trunk-jpl/src/c
Files:
9 edited

Legend:

Unmodified
Added
Removed

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

    r25252 r25308  
    184184
    185185        basalelement->GetInputValue(&active_element,HydrologydcMaskEplactiveEltEnum);
    186 
    187186        /*Check that all nodes are active, else return empty matrix*/
    188187        if(!active_element) {
    … …  
    213212        basalelement->FindParam(&dt,TimesteppingTimeStepEnum);
    214213        Input2* epl_thick_input = basalelement->GetInput2(HydrologydcEplThicknessSubstepEnum); _assert_(epl_thick_input);
    215         Input2* epl_head_input  = basalelement->GetInput2(EplHeadSubstepEnum);  _assert_(epl_head_input);
    216         Input2* base_input      = basalelement->GetInput2(BaseEnum); _assert_(base_input);
    217214
    218215        /* Start  looping on the number of gaussian points: */
    219216        Gauss* gauss = basalelement->NewGauss(2);
    220217        for(int ig=gauss->begin();ig<gauss->end();ig++){
    221                 gauss           ->GaussPoint(ig);
    222                 basalelement    ->JacobianDeterminant(&Jdet,xyz_list,gauss);
     218                gauss       ->GaussPoint(ig);
     219                basalelement->JacobianDeterminant(&Jdet,xyz_list,gauss);
    223220                basalelement->NodalFunctionsDerivatives(dbasis,xyz_list,gauss);
    224221                basalelement->NodalFunctions(basis,gauss);
    225222
    226                 epl_transmitivity = EplTransmitivity(basalelement,gauss,epl_thick_input,epl_head_input,base_input);
    227                 epl_storing                             = EplStoring(basalelement,gauss,epl_thick_input,epl_head_input,base_input);
     223                epl_transmitivity = EplTransmitivity(basalelement,gauss,epl_thick_input);
     224                epl_storing                     = EplStoring(basalelement,gauss,epl_thick_input);
    228225
    229226                /*Diffusivity*/
    230227                D_scalar=epl_transmitivity*gauss->weight*Jdet;
    231                 //D_scalar=gauss->weight*Jdet;
    232228                if(dt!=0.) D_scalar=D_scalar*dt;
    233229                for(int i=0;i<numnodes;i++){
    … …  
    236232                        }
    237233                }
    238 
    239234                /*Transient*/
    240235                if(dt!=0.){
    241                         basalelement->NodalFunctions(&basis[0],gauss);
    242236                        D_scalar=epl_storing*gauss->weight*Jdet;
    243                         //D_scalar=(epl_storing/epl_transmitivity)*gauss->weight*Jdet;
    244237                        for(int i=0;i<numnodes;i++) for(int j=0;j<numnodes;j++) Ke->values[i*numnodes+j] += D_scalar*basis[j]*basis[i];
    245 
    246238                        /*Transfer EPL part*/
    247239                        transfer=GetHydrologyKMatrixTransfer(basalelement);
    248240                        D_scalar=dt*transfer*gauss->weight*Jdet;
    249                         //D_scalar=dt*(transfer/epl_transmitivity)*gauss->weight*Jdet;
    250241                        for(int i=0;i<numnodes;i++) for(int j=0;j<numnodes;j++) Ke->values[i*numnodes+j] += D_scalar*basis[j]*basis[i];
    251242                }
    … …  
    291282        }
    292283        /*Intermediaries */
    293         int        smb_model;
    294         int        smb_averaging;
    295         int        smbsubstepping;
    296         int        hydrologysubstepping;
     284        int        smb_model,smb_averaging;
     285        int        smbsubstepping,hydrologysubstepping;
    297286        IssmDouble dt,scalar,water_head;
    298287        IssmDouble water_load,transfer,runoff_value;
    299288        IssmDouble epl_storing,epl_transmitivity;
    300         IssmDouble Jdet;
     289        IssmDouble Jdet,time;
    301290        IssmDouble residual,connectivity;
    302291
    … …  
    318307        basalelement->FindParam(&dt,TimesteppingTimeStepEnum);
    319308        basalelement ->FindParam(&smb_model,SmbEnum);
    320         basalelement->FindParam(&smb_averaging,SmbAveragingEnum);
    321309
    322310        Input2* epl_thick_input  = basalelement->GetInput2(HydrologydcEplThicknessSubstepEnum); _assert_(epl_thick_input);
    323311        Input2* sed_head_input   = basalelement->GetInput2(SedimentHeadSubstepEnum); _assert_(sed_head_input);
    324         Input2* epl_head_input   = basalelement->GetInput2(EplHeadSubstepEnum); _assert_(epl_head_input);
    325312        Input2* basal_melt_input = basalelement->GetInput2(BasalforcingsGroundediceMeltingRateEnum); _assert_(basal_melt_input);
    326313        Input2* residual_input   = basalelement->GetInput2(SedimentHeadResidualEnum); _assert_(residual_input);
    327         Input2* base_input       = basalelement->GetInput2(BaseEnum); _assert_(base_input);
    328 
    329         IssmDouble time;
    330         basalelement->FindParam(&time,TimeEnum);
    331314
    332315        if(dt!= 0.){
    … …  
    334317        }
    335318        if(smb_model==SMBgradientscomponentsEnum){
     319                basalelement->FindParam(&time,TimeEnum);
    336320                basalelement->FindParam(&smbsubstepping,SmbStepsPerStepEnum);
    337321                basalelement->FindParam(&hydrologysubstepping,HydrologyStepsPerStepEnum);
    … …  
    347331                else{
    348332                        //finer stepping in smb, we average the runoff from transient input
     333                        basalelement->FindParam(&smb_averaging,SmbAveragingEnum);
    349334                        dummy_input = basalelement->GetInput2(SmbRunoffTransientEnum,time-dt,time,smb_averaging); _assert_(dummy_input);
    350335                }
    … …  
    358343                basalelement ->JacobianDeterminant(&Jdet,xyz_list,gauss);
    359344                basalelement ->NodalFunctions(basis,gauss);
    360                 epl_storing     = EplStoring(basalelement,gauss,epl_thick_input,epl_head_input,base_input);
    361                 epl_transmitivity = EplTransmitivity(basalelement,gauss,epl_thick_input,epl_head_input,base_input);
     345                epl_storing     = EplStoring(basalelement,gauss,epl_thick_input);
     346                epl_transmitivity = EplTransmitivity(basalelement,gauss,epl_thick_input);
    362347
    363348                /*Loading term*/
    … …  
    366351                else                     runoff_value = 0.;
    367352                scalar = Jdet*gauss->weight*(water_load+runoff_value);
    368                 //scalar = Jdet*gauss->weight*(water_load)/epl_transmitivity;
    369353                if(dt!=0.) scalar = scalar*dt;
    370354                for(int i=0;i<numnodes;i++)pe->values[i]+=scalar*basis[i];
    … …  
    376360                        transfer=GetHydrologyPVectorTransfer(basalelement,gauss,sed_head_input);
    377361                        scalar = Jdet*gauss->weight*((water_head*epl_storing)+(dt*transfer));
    378                         //scalar = Jdet*gauss->weight*((water_head*epl_storing)+(dt*transfer))/epl_transmitivity;
    379362                        for(int i=0;i<numnodes;i++)pe->values[i]+=scalar*basis[i];
    380363                }
    … …  
    386369        for(int iv=0;iv<numvertices;iv++){
    387370                gauss->GaussVertex(iv);
    388                 epl_transmitivity = EplTransmitivity(basalelement,gauss,epl_thick_input,epl_head_input,base_input);
     371                epl_transmitivity = EplTransmitivity(basalelement,gauss,epl_thick_input);
    389372                connectivity = IssmDouble(basalelement->VertexConnectivity(iv));
    390373                residual_input->GetInputValue(&residual,gauss);
    391374                pe->values[iv]+=residual/connectivity;
    392                 //pe->values[iv]+=residual/(epl_transmitivity*connectivity);
    393375        }
    394376        /*Clean up and return*/
    … …  
    453435
    454436/*Intermediaries*/
    455 IssmDouble HydrologyDCEfficientAnalysis::EplStoring(Element* element,Gauss* gauss, Input2* epl_thick_input, Input2* epl_head_input, Input2* base_input){/*{{{*/
     437IssmDouble HydrologyDCEfficientAnalysis::EplStoring(Element* element,Gauss* gauss, Input2* epl_thick_input){/*{{{*/
    456438        IssmDouble epl_storing;
    457         IssmDouble water_sheet,storing;
    458         IssmDouble epl_thickness,prestep_head,base_elev;
    459         IssmDouble rho_freshwater        = element->FindParam(MaterialsRhoFreshwaterEnum);
    460         IssmDouble g                     = element->FindParam(ConstantsGEnum);
    461         IssmDouble epl_porosity                                  = element->FindParam(HydrologydcEplPorosityEnum);
    462         IssmDouble epl_compressibility   = element->FindParam(HydrologydcEplCompressibilityEnum);
    463         IssmDouble water_compressibility = element->FindParam(HydrologydcWaterCompressibilityEnum);
     439        IssmDouble epl_thickness;
     440        IssmDouble porewater_mass           = element->FindParam(HydrologydcEplPoreWaterMassEnum);
     441        IssmDouble layer_compressibility    = element->FindParam(HydrologydcEplLayerCompressibilityEnum);
    464442
    465443        epl_thick_input->GetInputValue(&epl_thickness,gauss);
    466         epl_head_input->GetInputValue(&prestep_head,gauss);
    467         base_input->GetInputValue(&base_elev,gauss);
    468         water_sheet=max(0.0,(prestep_head-base_elev));
    469         storing=rho_freshwater*g*epl_porosity*epl_thickness*(water_compressibility+(epl_compressibility/epl_porosity));
    470 
    471         /* //porosity for unconfined region */
    472         /* if (water_sheet<=0.9*epl_thickness){ */
    473         /*      epl_storing=epl_porosity; */
    474         /* } */
    475         /* //continuity ramp */
    476         /* else if((water_sheet<epl_thickness) && (water_sheet>0.9*epl_thickness)){ */
    477         /*      epl_storing=(epl_thickness-water_sheet)*(epl_porosity-storing)/(0.1*epl_thickness)+storing; */
    478         /* } */
    479         /* //storing coefficient for confined */
    480         /* else{ */
    481         /*      epl_storing=storing; */
    482         /* } */
    483         /* return epl_storing; */
    484         return storing;
    485 }/*}}}*/
    486 IssmDouble HydrologyDCEfficientAnalysis::EplTransmitivity(Element* element,Gauss* gauss, Input2* epl_thick_input, Input2* epl_head_input, Input2* base_input){/*{{{*/
     444        epl_storing=porewater_mass*epl_thickness*layer_compressibility;
     445
     446        return epl_storing;
     447}/*}}}*/
     448IssmDouble HydrologyDCEfficientAnalysis::EplTransmitivity(Element* element,Gauss* gauss, Input2* epl_thick_input){/*{{{*/
    487449        IssmDouble epl_transmitivity;
    488         IssmDouble water_sheet;
    489         IssmDouble epl_thickness,base_elev,prestep_head;
     450        IssmDouble epl_thickness;
    490451        IssmDouble epl_conductivity      = element->FindParam(HydrologydcEplConductivityEnum);
    491452        epl_thick_input->GetInputValue(&epl_thickness,gauss);
    492         epl_head_input->GetInputValue(&prestep_head,gauss);
    493         base_input->GetInputValue(&base_elev,gauss);
    494 
    495         water_sheet=max(0.0,(prestep_head-base_elev));
     453
    496454        epl_transmitivity=epl_conductivity*epl_thickness;
    497         //epl_transmitivity=max(1.0e-6,(epl_conductivity*min(water_sheet,epl_thickness)));
    498455        return epl_transmitivity;
    499456}/*}}}*/
    … …  
    584541        int         iseplthickcomp;
    585542        int         domaintype;
    586         IssmDouble  dt,A;
    587         IssmDouble  EPLgrad2;
    588         IssmDouble  EPL_N;
    589         IssmDouble  opening,closing;
    590543
    591544        femmodel->parameters->FindParam(&domaintype,DomainTypeEnum);
    … …  
    612565
    613566                element->GetInputValue(&active_element,HydrologydcMaskEplactiveEltEnum);
    614                 element->FindParam(&dt,TimesteppingTimeStepEnum);
    615 
    616                 /*For now, assuming just one way to compute EPL thickness*/
    617                 IssmDouble gravity          = element->FindParam(ConstantsGEnum);
    618                 IssmDouble rho_water        = element->FindParam(MaterialsRhoFreshwaterEnum);
    619                 IssmDouble rho_ice          = element->FindParam(MaterialsRhoIceEnum);
    620                 IssmDouble latentheat       = element->FindParam(MaterialsLatentheatEnum);
    621                 IssmDouble epl_conductivity = element->FindParam(HydrologydcEplConductivityEnum);
    622                 IssmDouble init_thick       =   element->FindParam(HydrologydcEplInitialThicknessEnum);
    623                 IssmDouble max_thick        =   element->FindParam(HydrologydcEplMaxThicknessEnum);
    624 
    625                 switch(domaintype){
    626                         case Domain2DhorizontalEnum: element->GetInputListOnVertices(&B[0],MaterialsRheologyBbarEnum); break;
    627                         case Domain3DEnum:           element->GetInputListOnVertices(&B[0],MaterialsRheologyBEnum); break;
    628                         default: _error_("not Implemented Yet");
    629                 }
    630 
    631                 element->GetInputListOnVertices(&eplhead[0],EplHeadSubstepEnum);
    632                 element->GetInputListOnVertices(&epl_slopeX[0],EplHeadSlopeXEnum);
    633                 element->GetInputListOnVertices(&epl_slopeY[0],EplHeadSlopeYEnum);
    634                 element->GetInputListOnVertices(&old_thickness[0],HydrologydcEplThicknessOldEnum);
    635                 element->GetInputListOnVertices(&ice_thickness[0],ThicknessEnum);
    636                 element->GetInputListOnVertices(&bed[0],BaseEnum);
    637                 element->GetInputListOnVertices(&n[0],MaterialsRheologyNEnum);
     567
     568                /*parameters*/
     569                IssmDouble gravity;
     570                IssmDouble rho_water;
     571                IssmDouble rho_ice;
     572                IssmDouble latentheat;
     573                IssmDouble epl_conductivity;
     574                IssmDouble init_thick;
     575                IssmDouble max_thick;
     576                IssmDouble dt;
     577
     578                /* Intermiedaries */
     579                IssmDouble  A;
     580                IssmDouble  EPLgrad2;
     581                IssmDouble  EPL_N;
     582                IssmDouble  opening,closing;
    638583
    639584                if(!active_element){
     585                        init_thick = element->FindParam(HydrologydcEplInitialThicknessEnum);
    640586                        /*Keeping thickness to initial value if EPL is not active*/
    641587                        for(int i=0;i<numnodes;i++){
    … …  
    644590                }
    645591                else{
     592                        switch(domaintype){
     593                                case Domain2DhorizontalEnum: element->GetInputListOnVertices(&B[0],MaterialsRheologyBbarEnum); break;
     594                                case Domain3DEnum:           element->GetInputListOnVertices(&B[0],MaterialsRheologyBEnum); break;
     595                                default: _error_("not Implemented Yet");
     596                        }
     597
     598                        element->FindParam(&max_thick,HydrologydcEplMaxThicknessEnum);
     599                        element->FindParam(&epl_conductivity,HydrologydcEplConductivityEnum);
     600                        element->FindParam(&latentheat,MaterialsLatentheatEnum);
     601                        element->FindParam(&rho_ice,MaterialsRhoIceEnum);
     602                        element->FindParam(&rho_water,MaterialsRhoFreshwaterEnum);
     603                        element->FindParam(&gravity,ConstantsGEnum);
     604                        element->FindParam(&dt,TimesteppingTimeStepEnum);
     605
     606                        element->GetInputListOnVertices(&eplhead[0],EplHeadSubstepEnum);
     607                        element->GetInputListOnVertices(&epl_slopeX[0],EplHeadSlopeXEnum);
     608                        element->GetInputListOnVertices(&epl_slopeY[0],EplHeadSlopeYEnum);
     609                        element->GetInputListOnVertices(&old_thickness[0],HydrologydcEplThicknessOldEnum);
     610                        element->GetInputListOnVertices(&ice_thickness[0],ThicknessEnum);
     611                        element->GetInputListOnVertices(&bed[0],BaseEnum);
     612                        element->GetInputListOnVertices(&n[0],MaterialsRheologyNEnum);
     613
    646614                        for(int i=0;i<numnodes;i++){
    647615                                A=pow(B[i],-n[i]);
    … …  
    705673        IssmDouble* eplhead       =xNew<IssmDouble>(numnodes);
    706674        IssmDouble* residual      =xNew<IssmDouble>(numnodes);
    707         IssmDouble* base          =xNew<IssmDouble>(numnodes);
    708675
    709676        IssmDouble init_thick    =basalelement->FindParam(HydrologydcEplInitialThicknessEnum);
    … …  
    712679        basalelement->GetInputValue(&active_element,HydrologydcMaskEplactiveEltEnum);
    713680
     681        basalelement-> GetInputListOnVertices(&sedhead[0],SedimentHeadSubstepEnum);
    714682        basalelement-> GetInputListOnVertices(&old_active[0],HydrologydcMaskEplactiveNodeEnum);
     683        basalelement-> GetInputListOnVertices(&residual[0],SedimentHeadResidualEnum);
    715684        basalelement-> GetInputListOnVertices(&epl_thickness[0],HydrologydcEplThicknessSubstepEnum);
    716         basalelement-> GetInputListOnVertices(&sedhead[0],SedimentHeadSubstepEnum);
    717685        basalelement-> GetInputListOnVertices(&eplhead[0],EplHeadSubstepEnum);
    718         basalelement-> GetInputListOnVertices(&residual[0],SedimentHeadResidualEnum);
    719         basalelement-> GetInputListOnVertices(&base[0],BaseEnum);
    720686
    721687        /*Get minimum sediment head of the element*/
    … …  
    769735        xDelete<IssmDouble>(eplhead);
    770736        xDelete<IssmDouble>(residual);
    771         xDelete<IssmDouble>(base);
    772737}
    773738/*}}}*/

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

    r25252 r25308  
    3535
    3636                /*Intermediaries*/
    37                 IssmDouble EplStoring(Element* element,Gauss* gauss, Input2* epl_thick_input, Input2* epl_head_input, Input2* base_input);
    38                 IssmDouble EplTransmitivity(Element* element,Gauss* gauss, Input2* epl_thick_input, Input2* epl_head_input, Input2* base_input);
     37                IssmDouble EplStoring(Element* element,Gauss* gauss, Input2* epl_thick_input);
     38                IssmDouble EplTransmitivity(Element* element,Gauss* gauss, Input2* epl_thick_input);
    3939                void GetHydrologyDCInefficientHmax(IssmDouble* ph_max,Element* element, Node* innode);
    4040                IssmDouble GetHydrologyKMatrixTransfer(Element* element);

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

    r25252 r25308  
    238238        Input2* sed_head_input = basalelement->GetInput2(SedimentHeadSubstepEnum);
    239239        Input2* base_input     = basalelement->GetInput2(BaseEnum);
    240         Input2* old_wh_input   = basalelement->GetInput2(SedimentHeadOldEnum);                  _assert_(old_wh_input);
    241240
    242241        /*Transfer related Inputs*/
    … …  
    244243                basalelement->GetInput2Value(&active_element,HydrologydcMaskEplactiveEltEnum);
    245244        }
    246 
    247245        /* Start  looping on the number of gaussian points: */
    248246        Gauss* gauss=basalelement->NewGauss(2);
    249247
    250248        for(int ig=gauss -> begin();ig<gauss->end();ig++){
    251                 gauss          -> GaussPoint(ig);
    252                 basalelement   -> JacobianDeterminant(&Jdet,xyz_list,gauss);
     249                gauss       ->GaussPoint(ig);
     250                basalelement->JacobianDeterminant(&Jdet,xyz_list,gauss);
    253251                basalelement->NodalFunctionsDerivatives(dbasis,xyz_list,gauss);
    254252                basalelement->NodalFunctions(basis,gauss);
    … …  
    259257                /*Diffusivity*/
    260258                D_scalar=sediment_transmitivity*gauss->weight*Jdet;
    261                 //D_scalar=gauss->weight*Jdet;
    262259                if(dt!=0.) D_scalar=D_scalar*dt;
    263260                for(int i=0;i<numnodes;i++){
    … …  
    266263                        }
    267264                }
    268 
    269265                /*Transient*/
    270266                if(dt!=0.){
    271267                        D_scalar=sediment_storing*gauss->weight*Jdet;
    272                         //D_scalar=(sediment_storing/sediment_transmitivity)*gauss->weight*Jdet;
    273268                        for(int i=0;i<numnodes;i++) for(int j=0;j<numnodes;j++) Ke->values[i*numnodes+j] += D_scalar*basis[j]*basis[i];
    274 
    275269                        /*Transfer EPL part*/
    276270                        if(isefficientlayer){
    … …  
    278272                                        transfer=GetHydrologyKMatrixTransfer(basalelement);
    279273                                        D_scalar=dt*transfer*gauss->weight*Jdet;
    280                                         //D_scalar=dt*(transfer/sediment_transmitivity)*gauss->weight*Jdet;
    281274                                        for(int i=0;i<numnodes;i++) for(int j=0;j<numnodes;j++) Ke->values[i*numnodes+j] += D_scalar*basis[j]*basis[i];
    282275                                }
    … …  
    298291
    299292        /*Intermediaries*/
    300         bool             thawed_element;
    301         int                      domaintype;
     293        bool            thawed_element;
     294        int             domaintype;
    302295        Element* basalelement;
    303296
    … …  
    328321        /*Intermediaries */
    329322        bool       active_element,isefficientlayer;
    330         int        smb_model;
    331         int        smbsubstepping;
    332         int        hydrologysubstepping;
    333         int        smb_averaging;
     323        int        smb_model,smbsubstepping;
     324        int        hydrologysubstepping,smb_averaging;
    334325        IssmDouble dt,scalar,sediment_storing;
    335326        IssmDouble water_head,sediment_transmitivity;
    336327        IssmDouble water_load,runoff_value,transfer;
    337         IssmDouble Jdet;
     328        IssmDouble Jdet,time;
    338329
    339330        IssmDouble *xyz_list             = NULL;
    … …  
    355346        basalelement->FindParam(&isefficientlayer,HydrologydcIsefficientlayerEnum);
    356347        basalelement->FindParam(&smb_model,SmbEnum);
    357         basalelement->FindParam(&smb_averaging,SmbAveragingEnum);
    358348
    359349        Input2* sed_head_input   = basalelement->GetInput2(SedimentHeadSubstepEnum);
    … …  
    363353        Input2* SedTrans_input   = basalelement->GetInput2(HydrologydcSedimentTransmitivityEnum); _assert_(SedTrans_input);
    364354
    365         IssmDouble time;
    366         basalelement->FindParam(&time,TimeEnum);
    367 
    368355        if(dt!= 0.){
    369356                old_wh_input = basalelement->GetInput2(SedimentHeadOldEnum); _assert_(old_wh_input);
    370357        }
    371358        if(smb_model==SMBgradientscomponentsEnum){
     359                basalelement->FindParam(&time,TimeEnum);
    372360                basalelement->FindParam(&smbsubstepping,SmbStepsPerStepEnum);
    373361                basalelement->FindParam(&hydrologysubstepping,HydrologyStepsPerStepEnum);
    … …  
    383371                else{
    384372                        //finer stepping in smb, we average the runoff from transient input
     373                        basalelement->FindParam(&smb_averaging,SmbAveragingEnum);
    385374                        dummy_input = basalelement->GetInput2(SmbRunoffTransientEnum,time-dt,time,smb_averaging); _assert_(dummy_input);
    386375                }
    … …  
    395384        /* Start  looping on the number of gaussian points: */
    396385        Gauss* gauss=basalelement->NewGauss(2);
    397 
    398         IssmDouble yts;
    399         basalelement->FindParam(&yts,ConstantsYtsEnum);
    400386
    401387        for(int ig=gauss->begin();ig<gauss->end();ig++){
    … …  
    411397                        else                     runoff_value = 0.;
    412398                        scalar = Jdet*gauss->weight*(water_load+runoff_value);
    413                         //scalar = Jdet*gauss->weight*(water_load)/sediment_transmitivity;
    414399                        if(dt!=0.) scalar = scalar*dt;
    415400                        for(int i=0;i<numnodes;i++){
    … …  
    424409                                else runoff_value = 0.;
    425410                                scalar = Jdet*gauss->weight*(water_load+runoff_value);
    426                                 //scalar = Jdet*gauss->weight*(water_load)/sediment_transmitivity;
    427411                                if(dt!=0.) scalar = scalar*dt;
    428412                                for(int i=0;i<numnodes;i++){
    … …  
    445429                                }
    446430                                scalar = Jdet*gauss->weight*((water_head*sediment_storing)+(dt*transfer));
    447                                 //scalar = Jdet*gauss->weight*((water_head*sediment_storing)+(dt*transfer))/sediment_transmitivity;
    448431                                for(int i=0;i<numnodes;i++)pe->values[i]+=scalar*basis[i];
    449432                        }
    450433                        else{
    451434                                scalar = Jdet*gauss->weight*(water_head*sediment_storing);
    452                                 //scalar = Jdet*gauss->weight*(water_head*sediment_storing)/sediment_transmitivity;
    453435                                for(int i=0;i<numnodes;i++)pe->values[i]+=scalar*basis[i];
    454436                        }
    … …  
    571553        IssmDouble storing,yield;
    572554        IssmDouble base_elev,prestep_head,water_sheet;
    573         IssmDouble rho_freshwater           = element->FindParam(MaterialsRhoFreshwaterEnum);
    574         IssmDouble g                        = element->FindParam(ConstantsGEnum);
    575         IssmDouble sediment_porosity        = element->FindParam(HydrologydcSedimentPorosityEnum);
     555        IssmDouble porewater_mass           = element->FindParam(HydrologydcSedimentPoreWaterMassEnum);
     556        IssmDouble layer_compressibility    = element->FindParam(HydrologydcSedimentLayerCompressibilityEnum);
    576557        IssmDouble sediment_thickness       = element->FindParam(HydrologydcSedimentThicknessEnum);
    577         IssmDouble sediment_compressibility = element->FindParam(HydrologydcSedimentCompressibilityEnum);
    578         IssmDouble water_compressibility    = element->FindParam(HydrologydcWaterCompressibilityEnum);
    579558        element->FindParam(&unconf_scheme,HydrologydcUnconfinedFlagEnum);
    580559        switch(unconf_scheme){
    581560        case 0:
    582                 sediment_storing=rho_freshwater*g*sediment_porosity*sediment_thickness*(water_compressibility+(sediment_compressibility/sediment_porosity));
     561                sediment_storing=porewater_mass*sediment_thickness*layer_compressibility;
    583562                break;
    584563        case 1:
     564                yield = element->FindParam(HydrologydcSedimentPorosityEnum);
    585565                base_input->GetInputValue(&base_elev,gauss);
    586566                sed_head_input->GetInputValue(&prestep_head,gauss);
     567
    587568                water_sheet=max(0.0,(prestep_head-(base_elev-sediment_thickness)));
    588 
    589                 /* if (water_sheet<sediment_thickness){ */
    590                 /*      sediment_storing=rho_freshwater*g*sediment_porosity*sediment_thickness*(water_compressibility+(sediment_compressibility/sediment_porosity)); */
    591                 /* } */
    592                 /* else{ */
    593                 /*      sediment_storing=sediment_porosity; */
    594                 /* } */
    595                 storing=rho_freshwater*g*sediment_porosity*sediment_thickness*(water_compressibility+(sediment_compressibility/sediment_porosity));
     569                storing=porewater_mass*sediment_thickness*layer_compressibility;
    596570                //using logistic function for heavyside approximation
    597571                expfac=10.;
    598                 yield=sediment_porosity;
    599572                sediment_storing=yield+(storing-yield)/(1+exp(-2*expfac*(water_sheet-0.99*sediment_thickness)));
    600573                break;
    … …  
    606579IssmDouble HydrologyDCInefficientAnalysis::SedimentTransmitivity(Element* element,Gauss* gauss,Input2* sed_head_input, Input2* base_input,Input2* SedTrans_input){/*{{{*/
    607580        int unconf_scheme;
    608         IssmDouble ratio,expfac;
    609581        IssmDouble sediment_transmitivity;
    610582        IssmDouble FullLayer_transmitivity;
    611         IssmDouble meltingrate;
    612         IssmDouble groundedice;
    613583        IssmDouble base_elev,prestep_head,water_sheet;
    614584        IssmDouble sediment_thickness       = element->FindParam(HydrologydcSedimentThicknessEnum);

  • issm/trunk-jpl/src/c/classes/Inputs2/TransientInput2.cpp

    r25252 r25308  
    420420                /*If already processed return*/
    421421                if(fabs(this->current_step-this_step)<1.e-5) return;
    422                 //              if(this->current_step>this_step-1.e-5 && this->current_step<this_step+1.e-5) return;
    423422
    424423                /*Prepare input*/
    … …  
    457456        }
    458457        mid_step=reCast<IssmDouble>(start_offset)+0.5*timespan;
    459 
    460458        /*If already processed return, we set step in the middle of the interval*/
    461459        if(fabs(this->current_step-mid_step)<1.e-5) return;

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

    r25252 r25308  
    11/*!\file: CreateParameters.cpp
    22 * \brief general driver for creating parameters dataset
    3  */ 
     3 */
    44
    55#ifdef HAVE_CONFIG_H
    … …  
    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(SealevelriseRunCountEnum,1));
    6666
    6767          {/*This is specific to ice...*/
    … …  
    9898          }
    9999
    100         /*amr properties*/     
     100        /*amr properties*/
    101101        int amrtype,amr_frequency;
    102102        iomodel->FindConstant(&amr_frequency,"md.transient.amr_frequency");
    … …  
    156156                case LinearFloatingMeltRateEnum:
    157157                        iomodel->FindConstant(&interp,"md.timestepping.interp_forcings");
    158                         iomodel->FetchData(&transparam,&N,&M,"md.basalforcings.deepwater_melting_rate"); 
     158                        iomodel->FetchData(&transparam,&N,&M,"md.basalforcings.deepwater_melting_rate");
    159159                        if(N==1){
    160160                                _assert_(M==1);
    … …  
    166166                        }
    167167                        xDelete<IssmDouble>(transparam);
    168                         iomodel->FetchData(&transparam,&N,&M,"md.basalforcings.upperwater_melting_rate"); 
     168                        iomodel->FetchData(&transparam,&N,&M,"md.basalforcings.upperwater_melting_rate");
    169169                        if(N==1){
    170170                                _assert_(M==1);
    … …  
    176176                        }
    177177                        xDelete<IssmDouble>(transparam);
    178                         iomodel->FetchData(&transparam,&N,&M,"md.basalforcings.deepwater_elevation"); 
     178                        iomodel->FetchData(&transparam,&N,&M,"md.basalforcings.deepwater_elevation");
    179179                        if(N==1){
    180180                                _assert_(M==1);
    … …  
    183183                        else{
    184184                                _assert_(N==2);
    185                                 parameters->AddObject(new TransientParam(BasalforcingsDeepwaterElevationEnum,&transparam[0],&transparam[M],interp,M)); 
    186                         }
    187                         xDelete<IssmDouble>(transparam);
    188                         iomodel->FetchData(&transparam,&N,&M,"md.basalforcings.upperwater_elevation"); 
     185                                parameters->AddObject(new TransientParam(BasalforcingsDeepwaterElevationEnum,&transparam[0],&transparam[M],interp,M));
     186                        }
     187                        xDelete<IssmDouble>(transparam);
     188                        iomodel->FetchData(&transparam,&N,&M,"md.basalforcings.upperwater_elevation");
    189189                        if(N==1){
    190190                                _assert_(M==1);
    … …  
    226226                        parameters->AddObject(iomodel->CopyConstantObject("md.basalforcings.isplume",BasalforcingsPicoIsplumeEnum));
    227227                        iomodel->FetchData(&transparam,&M,&N,"md.basalforcings.farocean_temperature");
    228                         _assert_(M>=1 && N>=1); 
     228                        _assert_(M>=1 && N>=1);
    229229                        parameters->AddObject(new TransientArrayParam(BasalforcingsPicoFarOceantemperatureEnum,transparam,&transparam[N*(M-1)],interp,N,M));
    230230                        xDelete<IssmDouble>(transparam);
    231231                        iomodel->FetchData(&transparam,&M,&N,"md.basalforcings.farocean_salinity");
    232                         _assert_(M>=1 && N>=1); 
     232                        _assert_(M>=1 && N>=1);
    233233                        parameters->AddObject(new TransientArrayParam(BasalforcingsPicoFarOceansalinityEnum,transparam,&transparam[N*(M-1)],interp,N,M));
    234234                        xDelete<IssmDouble>(transparam);
    … …  
    237237                        parameters->AddObject(iomodel->CopyConstantObject("md.basalforcings.num_basins",BasalforcingsIsmip6NumBasinsEnum));
    238238                        parameters->AddObject(iomodel->CopyConstantObject("md.basalforcings.gamma_0",BasalforcingsIsmip6Gamma0Enum));
    239                         parameters->AddObject(iomodel->CopyConstantObject("md.basalforcings.islocal",BasalforcingsIsmip6IsLocalEnum)); 
     239                        parameters->AddObject(iomodel->CopyConstantObject("md.basalforcings.islocal",BasalforcingsIsmip6IsLocalEnum));
    240240                        iomodel->FetchData(&transparam,&M,&N,"md.basalforcings.delta_t");
    241241                        parameters->AddObject(new DoubleVecParam(BasalforcingsIsmip6DeltaTEnum,transparam,N));
    … …  
    279279        }
    280280        iomodel->FindConstant(&time,"md.timestepping.start_time");
    281         parameters->AddObject(new DoubleParam(TimeEnum,time)); 
    282         parameters->AddObject(new IntParam(StepEnum,0)); 
     281        parameters->AddObject(new DoubleParam(TimeEnum,time));
     282        parameters->AddObject(new IntParam(StepEnum,0));
    283283
    284284        /*By default, save all results*/
    … …  
    421421        iomodel->FindConstant(&hydrology_model,"md.hydrology.model");
    422422        if(hydrology_model==HydrologydcEnum){
    423                 /*FIXME: this cshould go to Analysis!!!*/
    424                 parameters->AddObject(iomodel->CopyConstantObject("md.hydrology.sediment_compressibility",HydrologydcSedimentCompressibilityEnum));
     423                IssmDouble sedcomp, sedporo, watcomp, rhofresh, g;
     424
     425                /*FIXME: this should go to Analysis!!!*/
    425426                parameters->AddObject(iomodel->CopyConstantObject("md.hydrology.sediment_porosity",HydrologydcSedimentPorosityEnum));
    426427                parameters->AddObject(iomodel->CopyConstantObject("md.hydrology.sediment_thickness",HydrologydcSedimentThicknessEnum));
    427                 parameters->AddObject(iomodel->CopyConstantObject("md.hydrology.water_compressibility",HydrologydcWaterCompressibilityEnum));
    428428                parameters->AddObject(iomodel->CopyConstantObject("md.hydrology.isefficientlayer",HydrologydcIsefficientlayerEnum));
     429
     430                iomodel->FindConstant(&sedcomp,"md.hydrology.sediment_compressibility");
     431                iomodel->FindConstant(&sedporo,"md.hydrology.sediment_porosity");
     432                iomodel->FindConstant(&watcomp,"md.hydrology.water_compressibility");
     433                iomodel->FindConstant(&rhofresh,"md.materials.rho_freshwater");
     434                iomodel->FindConstant(&g,"md.constants.g");
     435
     436                parameters->AddObject(new DoubleParam(HydrologydcSedimentLayerCompressibilityEnum,(watcomp + sedcomp/sedporo)));
     437                parameters->AddObject(new DoubleParam(HydrologydcSedimentPoreWaterMassEnum,(rhofresh*g*sedporo)));
    429438
    430439                bool isefficientlayer;
    431440                iomodel->FindConstant(&isefficientlayer,"md.hydrology.isefficientlayer");
    432441                if(isefficientlayer){
    433                         parameters->AddObject(iomodel->CopyConstantObject("md.hydrology.epl_compressibility",HydrologydcEplCompressibilityEnum));
    434                         parameters->AddObject(iomodel->CopyConstantObject("md.hydrology.epl_porosity",HydrologydcEplPorosityEnum));
     442                        IssmDouble eplcomp, eplporo;
    435443                        parameters->AddObject(iomodel->CopyConstantObject("md.hydrology.epl_initial_thickness",HydrologydcEplInitialThicknessEnum));
    436444                        parameters->AddObject(iomodel->CopyConstantObject("md.hydrology.epl_colapse_thickness",HydrologydcEplColapseThicknessEnum));
    437445                        parameters->AddObject(iomodel->CopyConstantObject("md.hydrology.epl_max_thickness",HydrologydcEplMaxThicknessEnum));
    438446                        parameters->AddObject(iomodel->CopyConstantObject("md.hydrology.epl_conductivity",HydrologydcEplConductivityEnum));
     447
     448                        iomodel->FindConstant(&eplcomp,"md.hydrology.epl_compressibility");
     449                        iomodel->FindConstant(&eplporo,"md.hydrology.epl_porosity");
     450                        parameters->AddObject(new DoubleParam(HydrologydcEplLayerCompressibilityEnum,(watcomp + eplcomp/eplporo)));
     451                        parameters->AddObject(new DoubleParam(HydrologydcEplPoreWaterMassEnum,(rhofresh*g*eplporo)));
     452
    439453                }
    440454        }
    … …  
    472486        if(mass_flux_present){
    473487
    474                 /*Fetch the mass flux segments necessary to compute the mass fluxes.  Build a DoubleMatArrayParam object out of them: */ 
     488                /*Fetch the mass flux segments necessary to compute the mass fluxes.  Build a DoubleMatArrayParam object out of them: */
    475489                iomodel->FetchData(&array,&mdims_array,&ndims_array,&mass_flux_num_profiles,"md.qmu.mass_flux_segments");
    476490                if(mass_flux_num_profiles==0)_error_("mass_flux_num_profiles is 0, when MassFlux computations were requested!");
    … …  
    518532                        xDelete<IssmDouble>(matrix);
    519533                }
    520                 xDelete<int>(mdims_array); 
     534                xDelete<int>(mdims_array);
    521535                xDelete<int>(ndims_array);
    522536                xDelete<IssmDouble*>(array);

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

    r25293 r25308  
    182182syn keyword cConstant HydrologyStorageEnum
    183183syn keyword cConstant HydrologydcEplColapseThicknessEnum
    184 syn keyword cConstant HydrologydcEplCompressibilityEnum
    185184syn keyword cConstant HydrologydcEplConductivityEnum
    186185syn keyword cConstant HydrologydcEplInitialThicknessEnum
     186syn keyword cConstant HydrologydcEplLayerCompressibilityEnum
    187187syn keyword cConstant HydrologydcEplMaxThicknessEnum
    188 syn keyword cConstant HydrologydcEplPorosityEnum
     188syn keyword cConstant HydrologydcEplPoreWaterMassEnum
    189189syn keyword cConstant HydrologydcEplThickCompEnum
    190190syn keyword cConstant HydrologydcEplflipLockEnum
    … …  
    195195syn keyword cConstant HydrologydcPenaltyLockEnum
    196196syn keyword cConstant HydrologydcRelTolEnum
    197 syn keyword cConstant HydrologydcSedimentCompressibilityEnum
    198197syn keyword cConstant HydrologydcSedimentlimitEnum
    199198syn keyword cConstant HydrologydcSedimentlimitFlagEnum
     199syn keyword cConstant HydrologydcSedimentLayerCompressibilityEnum
     200syn keyword cConstant HydrologydcSedimentPoreWaterMassEnum
    200201syn keyword cConstant HydrologydcSedimentPorosityEnum
    201202syn keyword cConstant HydrologydcSedimentThicknessEnum
    202203syn keyword cConstant HydrologydcTransferFlagEnum
    203204syn keyword cConstant HydrologydcUnconfinedFlagEnum
    204 syn keyword cConstant HydrologydcWaterCompressibilityEnum
    205205syn keyword cConstant HydrologyshreveStabilizationEnum
    206206syn keyword cConstant IcecapToEarthCommEnum
    … …  
    13611361syn keyword cType Cfsurfacesquare
    13621362syn keyword cType Channel
     1363syn keyword cType classes
    13631364syn keyword cType Constraint
    13641365syn keyword cType Constraints
    … …  
    13671368syn keyword cType ControlInput2
    13681369syn keyword cType Covertree
     1370syn keyword cType DatasetInput2
    13691371syn keyword cType DataSetParam
    1370 syn keyword cType DatasetInput2
    13711372syn keyword cType Definition
    13721373syn keyword cType DependentObject
    … …  
    13811382syn keyword cType ElementInput2
    13821383syn keyword cType ElementMatrix
     1384syn keyword cType Elements
    13831385syn keyword cType ElementVector
    1384 syn keyword cType Elements
    13851386syn keyword cType ExponentialVariogram
    13861387syn keyword cType ExternalResult
    … …  
    13891390syn keyword cType Friction
    13901391syn keyword cType Gauss
     1392syn keyword cType GaussianVariogram
     1393syn keyword cType gaussobjects
    13911394syn keyword cType GaussPenta
    13921395syn keyword cType GaussSeg
    13931396syn keyword cType GaussTetra
    13941397syn keyword cType GaussTria
    1395 syn keyword cType GaussianVariogram
    13961398syn keyword cType GenericExternalResult
    13971399syn keyword cType GenericOption
    … …  
    14081410syn keyword cType IssmDirectApplicInterface
    14091411syn keyword cType IssmParallelDirectApplicInterface
     1412syn keyword cType krigingobjects
    14101413syn keyword cType Load
    14111414syn keyword cType Loads
    … …  
    14181421syn keyword cType Matice
    14191422syn keyword cType Matlitho
     1423syn keyword cType matrixobjects
    14201424syn keyword cType MatrixParam
    14211425syn keyword cType Misfit
    … …  
    14301434syn keyword cType Observations
    14311435syn keyword cType Option
     1436syn keyword cType Options
    14321437syn keyword cType OptionUtilities
    1433 syn keyword cType Options
    14341438syn keyword cType Param
    14351439syn keyword cType Parameters
    … …  
    14451449syn keyword cType Regionaloutput
    14461450syn keyword cType Results
     1451syn keyword cType Riftfront
    14471452syn keyword cType RiftStruct
    1448 syn keyword cType Riftfront
    14491453syn keyword cType SealevelMasks
    14501454syn keyword cType Seg
    14511455syn keyword cType SegInput2
     1456syn keyword cType Segment
    14521457syn keyword cType SegRef
    1453 syn keyword cType Segment
    14541458syn keyword cType SpcDynamic
    14551459syn keyword cType SpcStatic
    … …  
    14701474syn keyword cType Vertex
    14711475syn keyword cType Vertices
    1472 syn keyword cType classes
    1473 syn keyword cType gaussobjects
    1474 syn keyword cType krigingobjects
    1475 syn keyword cType matrixobjects
    14761476syn keyword cType AdjointBalancethickness2Analysis
    14771477syn keyword cType AdjointBalancethicknessAnalysis
    … …  
    14921492syn keyword cType FreeSurfaceBaseAnalysis
    14931493syn keyword cType FreeSurfaceTopAnalysis
     1494syn keyword cType GiaAnalysis
    14941495syn keyword cType GLheightadvectionAnalysis
    1495 syn keyword cType GiaAnalysis
    14961496syn keyword cType HydrologyDCEfficientAnalysis
    14971497syn keyword cType HydrologyDCInefficientAnalysis

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

    r25293 r25308  
    176176        HydrologyStorageEnum,
    177177        HydrologydcEplColapseThicknessEnum,
    178         HydrologydcEplCompressibilityEnum,
    179178        HydrologydcEplConductivityEnum,
    180179        HydrologydcEplInitialThicknessEnum,
     180        HydrologydcEplLayerCompressibilityEnum,
    181181        HydrologydcEplMaxThicknessEnum,
    182         HydrologydcEplPorosityEnum,
     182        HydrologydcEplPoreWaterMassEnum,
    183183        HydrologydcEplThickCompEnum,
    184184        HydrologydcEplflipLockEnum,
    … …  
    189189        HydrologydcPenaltyLockEnum,
    190190        HydrologydcRelTolEnum,
    191         HydrologydcSedimentCompressibilityEnum,
    192191        HydrologydcSedimentlimitEnum,
    193192        HydrologydcSedimentlimitFlagEnum,
     193        HydrologydcSedimentLayerCompressibilityEnum,
     194        HydrologydcSedimentPoreWaterMassEnum,
    194195        HydrologydcSedimentPorosityEnum,
    195196        HydrologydcSedimentThicknessEnum,
    196197        HydrologydcTransferFlagEnum,
    197198        HydrologydcUnconfinedFlagEnum,
    198         HydrologydcWaterCompressibilityEnum,
    199199        HydrologyshreveStabilizationEnum,
    200200        IcecapToEarthCommEnum,

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

    r25293 r25308  
    184184                case HydrologyStorageEnum : return "HydrologyStorage";
    185185                case HydrologydcEplColapseThicknessEnum : return "HydrologydcEplColapseThickness";
    186                 case HydrologydcEplCompressibilityEnum : return "HydrologydcEplCompressibility";
    187186                case HydrologydcEplConductivityEnum : return "HydrologydcEplConductivity";
    188187                case HydrologydcEplInitialThicknessEnum : return "HydrologydcEplInitialThickness";
     188                case HydrologydcEplLayerCompressibilityEnum : return "HydrologydcEplLayerCompressibility";
    189189                case HydrologydcEplMaxThicknessEnum : return "HydrologydcEplMaxThickness";
    190                 case HydrologydcEplPorosityEnum : return "HydrologydcEplPorosity";
     190                case HydrologydcEplPoreWaterMassEnum : return "HydrologydcEplPoreWaterMass";
    191191                case HydrologydcEplThickCompEnum : return "HydrologydcEplThickComp";
    192192                case HydrologydcEplflipLockEnum : return "HydrologydcEplflipLock";
    … …  
    197197                case HydrologydcPenaltyLockEnum : return "HydrologydcPenaltyLock";
    198198                case HydrologydcRelTolEnum : return "HydrologydcRelTol";
    199                 case HydrologydcSedimentCompressibilityEnum : return "HydrologydcSedimentCompressibility";
    200199                case HydrologydcSedimentlimitEnum : return "HydrologydcSedimentlimit";
    201200                case HydrologydcSedimentlimitFlagEnum : return "HydrologydcSedimentlimitFlag";
     201                case HydrologydcSedimentLayerCompressibilityEnum : return "HydrologydcSedimentLayerCompressibility";
     202                case HydrologydcSedimentPoreWaterMassEnum : return "HydrologydcSedimentPoreWaterMass";
    202203                case HydrologydcSedimentPorosityEnum : return "HydrologydcSedimentPorosity";
    203204                case HydrologydcSedimentThicknessEnum : return "HydrologydcSedimentThickness";
    204205                case HydrologydcTransferFlagEnum : return "HydrologydcTransferFlag";
    205206                case HydrologydcUnconfinedFlagEnum : return "HydrologydcUnconfinedFlag";
    206                 case HydrologydcWaterCompressibilityEnum : return "HydrologydcWaterCompressibility";
    207207                case HydrologyshreveStabilizationEnum : return "HydrologyshreveStabilization";
    208208                case IcecapToEarthCommEnum : return "IcecapToEarthComm";

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

    r25293 r25308  
    187187              else if (strcmp(name,"HydrologyStorage")==0) return HydrologyStorageEnum;
    188188              else if (strcmp(name,"HydrologydcEplColapseThickness")==0) return HydrologydcEplColapseThicknessEnum;
    189               else if (strcmp(name,"HydrologydcEplCompressibility")==0) return HydrologydcEplCompressibilityEnum;
    190189              else if (strcmp(name,"HydrologydcEplConductivity")==0) return HydrologydcEplConductivityEnum;
    191190              else if (strcmp(name,"HydrologydcEplInitialThickness")==0) return HydrologydcEplInitialThicknessEnum;
     191              else if (strcmp(name,"HydrologydcEplLayerCompressibility")==0) return HydrologydcEplLayerCompressibilityEnum;
    192192              else if (strcmp(name,"HydrologydcEplMaxThickness")==0) return HydrologydcEplMaxThicknessEnum;
    193               else if (strcmp(name,"HydrologydcEplPorosity")==0) return HydrologydcEplPorosityEnum;
     193              else if (strcmp(name,"HydrologydcEplPoreWaterMass")==0) return HydrologydcEplPoreWaterMassEnum;
    194194              else if (strcmp(name,"HydrologydcEplThickComp")==0) return HydrologydcEplThickCompEnum;
    195195              else if (strcmp(name,"HydrologydcEplflipLock")==0) return HydrologydcEplflipLockEnum;
    … …  
    200200              else if (strcmp(name,"HydrologydcPenaltyLock")==0) return HydrologydcPenaltyLockEnum;
    201201              else if (strcmp(name,"HydrologydcRelTol")==0) return HydrologydcRelTolEnum;
    202               else if (strcmp(name,"HydrologydcSedimentCompressibility")==0) return HydrologydcSedimentCompressibilityEnum;
    203202              else if (strcmp(name,"HydrologydcSedimentlimit")==0) return HydrologydcSedimentlimitEnum;
    204203              else if (strcmp(name,"HydrologydcSedimentlimitFlag")==0) return HydrologydcSedimentlimitFlagEnum;
     204              else if (strcmp(name,"HydrologydcSedimentLayerCompressibility")==0) return HydrologydcSedimentLayerCompressibilityEnum;
     205              else if (strcmp(name,"HydrologydcSedimentPoreWaterMass")==0) return HydrologydcSedimentPoreWaterMassEnum;
    205206              else if (strcmp(name,"HydrologydcSedimentPorosity")==0) return HydrologydcSedimentPorosityEnum;
    206207              else if (strcmp(name,"HydrologydcSedimentThickness")==0) return HydrologydcSedimentThicknessEnum;
    207208              else if (strcmp(name,"HydrologydcTransferFlag")==0) return HydrologydcTransferFlagEnum;
    208209              else if (strcmp(name,"HydrologydcUnconfinedFlag")==0) return HydrologydcUnconfinedFlagEnum;
    209               else if (strcmp(name,"HydrologydcWaterCompressibility")==0) return HydrologydcWaterCompressibilityEnum;
    210210              else if (strcmp(name,"HydrologyshreveStabilization")==0) return HydrologyshreveStabilizationEnum;
    211211              else if (strcmp(name,"IcecapToEarthComm")==0) return IcecapToEarthCommEnum;
Note: See TracChangeset for help on using the changeset viewer.