Changeset 23644


Ignore:
Timestamp:
01/19/19 12:48:01 (6 years ago)
Author:
Mathieu Morlighem
Message:

NEW: removing matpar from femmodel

Location:
issm/trunk-jpl/src/c
Files:
2 deleted
52 edited

Legend:

Unmodified
Added
Removed

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

    r23612 r23644  
    114114                                        ./classes/Materials/Matlitho.cpp\
    115115                                        ./classes/Materials/Matestar.cpp\
    116                                         ./classes/Materials/Matpar.cpp\
    117116                                        ./classes/Constraints/Constraints.cpp\
    118117                                        ./classes/Constraints/SpcStatic.cpp\

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

    r23629 r23644  
    390390        else enthalpy_enum=EnthalpyEnum;
    391391
    392         IssmDouble latentheat = element->GetMaterialParameter(MaterialsLatentheatEnum);
    393         IssmDouble rho_ice    = element->GetMaterialParameter(MaterialsRhoIceEnum);
    394         IssmDouble rho_water  = element->GetMaterialParameter(MaterialsRhoFreshwaterEnum);
    395         IssmDouble beta          = element->GetMaterialParameter(MaterialsBetaEnum);
     392        IssmDouble latentheat = element->FindParam(MaterialsLatentheatEnum);
     393        IssmDouble rho_ice    = element->FindParam(MaterialsRhoIceEnum);
     394        IssmDouble rho_water  = element->FindParam(MaterialsRhoFreshwaterEnum);
     395        IssmDouble beta          = element->FindParam(MaterialsBetaEnum);
    396396        IssmDouble kappa                 = EnthalpyDiffusionParameterVolume(element,enthalpy_enum);     _assert_(kappa>=0.);
    397397        IssmDouble kappa_mix;
    … …  
    584584        element->FindParam(&dt,TimesteppingTimeStepEnum);
    585585        element->FindParam(&stabilization,ThermalStabilizationEnum);
    586         IssmDouble  rho_water           = element->GetMaterialParameter(MaterialsRhoSeawaterEnum);
    587         IssmDouble  rho_ice             = element->GetMaterialParameter(MaterialsRhoIceEnum);
    588         IssmDouble  gravity             = element->GetMaterialParameter(ConstantsGEnum);
    589         IssmDouble  heatcapacity        = element->GetMaterialParameter(MaterialsHeatcapacityEnum);
    590         IssmDouble  thermalconductivity = element->GetMaterialParameter(MaterialsThermalconductivityEnum);
     586        IssmDouble  rho_water           = element->FindParam(MaterialsRhoSeawaterEnum);
     587        IssmDouble  rho_ice             = element->FindParam(MaterialsRhoIceEnum);
     588        IssmDouble  gravity             = element->FindParam(ConstantsGEnum);
     589        IssmDouble  heatcapacity        = element->FindParam(MaterialsHeatcapacityEnum);
     590        IssmDouble  thermalconductivity = element->FindParam(MaterialsThermalconductivityEnum);
    591591        Input* vx_input  = element->GetInput(VxEnum);     _assert_(vx_input);
    592592        Input* vy_input  = element->GetInput(VyEnum);     _assert_(vy_input);
    … …  
    710710        element->GetVerticesCoordinatesBase(&xyz_list_base);
    711711        element->FindParam(&dt,TimesteppingTimeStepEnum);
    712         IssmDouble  gravity             = element->GetMaterialParameter(ConstantsGEnum);
    713         IssmDouble  rho_water           = element->GetMaterialParameter(MaterialsRhoSeawaterEnum);
    714         IssmDouble  rho_ice             = element->GetMaterialParameter(MaterialsRhoIceEnum);
    715         IssmDouble  heatcapacity        = element->GetMaterialParameter(MaterialsHeatcapacityEnum);
    716         IssmDouble  mixed_layer_capacity= element->GetMaterialParameter(MaterialsMixedLayerCapacityEnum);
    717         IssmDouble  thermal_exchange_vel= element->GetMaterialParameter(MaterialsThermalExchangeVelocityEnum);
     712        IssmDouble  gravity             = element->FindParam(ConstantsGEnum);
     713        IssmDouble  rho_water           = element->FindParam(MaterialsRhoSeawaterEnum);
     714        IssmDouble  rho_ice             = element->FindParam(MaterialsRhoIceEnum);
     715        IssmDouble  heatcapacity        = element->FindParam(MaterialsHeatcapacityEnum);
     716        IssmDouble  mixed_layer_capacity= element->FindParam(MaterialsMixedLayerCapacityEnum);
     717        IssmDouble  thermal_exchange_vel= element->FindParam(MaterialsThermalExchangeVelocityEnum);
    718718
    719719        /* Start  looping on the number of gaussian points: */
    … …  
    786786        /*Retrieve all inputs and parameters*/
    787787        element->GetVerticesCoordinates(&xyz_list);
    788         IssmDouble  rho_ice             = element->GetMaterialParameter(MaterialsRhoIceEnum);
    789         IssmDouble  heatcapacity        = element->GetMaterialParameter(MaterialsHeatcapacityEnum);
    790         IssmDouble  thermalconductivity = element->GetMaterialParameter(MaterialsThermalconductivityEnum);
    791         IssmDouble  temperateiceconductivity = element->GetMaterialParameter(MaterialsTemperateiceconductivityEnum);
    792         IssmDouble  beta                = element->GetMaterialParameter(MaterialsBetaEnum);
    793         IssmDouble  latentheat          = element->GetMaterialParameter(MaterialsLatentheatEnum);
     788        IssmDouble  rho_ice             = element->FindParam(MaterialsRhoIceEnum);
     789        IssmDouble  heatcapacity        = element->FindParam(MaterialsHeatcapacityEnum);
     790        IssmDouble  thermalconductivity = element->FindParam(MaterialsThermalconductivityEnum);
     791        IssmDouble  temperateiceconductivity = element->FindParam(MaterialsTemperateiceconductivityEnum);
     792        IssmDouble  beta                = element->FindParam(MaterialsBetaEnum);
     793        IssmDouble  latentheat          = element->FindParam(MaterialsLatentheatEnum);
    794794        element->FindParam(&dt,TimesteppingTimeStepEnum);
    795795        element->FindParam(&stabilization,ThermalStabilizationEnum);
    … …  
    912912        Input* meltingrate_input         = element->GetInput(BasalforcingsGroundediceMeltingRateEnum);                                                   _assert_(meltingrate_input);
    913913        Input* geothermalflux_input = element->GetInput(BasalforcingsGeothermalfluxEnum); _assert_(geothermalflux_input);
    914         IssmDouble  rho_ice                      = element->GetMaterialParameter(MaterialsRhoIceEnum);
     914        IssmDouble  rho_ice                      = element->FindParam(MaterialsRhoIceEnum);
    915915
    916916        /*Build friction element, needed later: */
    … …  
    998998        element->FindParam(&dt,TimesteppingTimeStepEnum);
    999999        Input*      pressure_input=element->GetInput(PressureEnum); _assert_(pressure_input);
    1000         IssmDouble  gravity             = element->GetMaterialParameter(ConstantsGEnum);
    1001         IssmDouble  rho_water           = element->GetMaterialParameter(MaterialsRhoSeawaterEnum);
    1002         IssmDouble  rho_ice             = element->GetMaterialParameter(MaterialsRhoIceEnum);
    1003         IssmDouble  heatcapacity        = element->GetMaterialParameter(MaterialsHeatcapacityEnum);
    1004         IssmDouble  mixed_layer_capacity= element->GetMaterialParameter(MaterialsMixedLayerCapacityEnum);
    1005         IssmDouble  thermal_exchange_vel= element->GetMaterialParameter(MaterialsThermalExchangeVelocityEnum);
     1000        IssmDouble  gravity             = element->FindParam(ConstantsGEnum);
     1001        IssmDouble  rho_water           = element->FindParam(MaterialsRhoSeawaterEnum);
     1002        IssmDouble  rho_ice             = element->FindParam(MaterialsRhoIceEnum);
     1003        IssmDouble  heatcapacity        = element->FindParam(MaterialsHeatcapacityEnum);
     1004        IssmDouble  mixed_layer_capacity= element->FindParam(MaterialsMixedLayerCapacityEnum);
     1005        IssmDouble  thermal_exchange_vel= element->FindParam(MaterialsThermalExchangeVelocityEnum);
    10061006
    10071007        /* Start  looping on the number of gaussian points: */
    … …  
    11521152IssmDouble     EnthalpyAnalysis::EnthalpyDiffusionParameter(Element* element,IssmDouble enthalpy,IssmDouble pressure){/*{{{*/
    11531153
    1154         IssmDouble heatcapacity             = element->GetMaterialParameter(MaterialsHeatcapacityEnum);
    1155         IssmDouble temperateiceconductivity = element->GetMaterialParameter(MaterialsTemperateiceconductivityEnum);
    1156         IssmDouble thermalconductivity      = element->GetMaterialParameter(MaterialsThermalconductivityEnum);
     1154        IssmDouble heatcapacity             = element->FindParam(MaterialsHeatcapacityEnum);
     1155        IssmDouble temperateiceconductivity = element->FindParam(MaterialsTemperateiceconductivityEnum);
     1156        IssmDouble thermalconductivity      = element->FindParam(MaterialsThermalconductivityEnum);
    11571157
    11581158        if(enthalpy < PureIceEnthalpy(element,pressure)){
    … …  
    15071507        IssmDouble temperature, waterfraction;
    15081508        IssmDouble kappa_w = 0.6; // thermal conductivity of water (in W/m/K)
    1509         IssmDouble kappa_i = element->GetMaterialParameter(MaterialsThermalconductivityEnum);
     1509        IssmDouble kappa_i = element->FindParam(MaterialsThermalconductivityEnum);
    15101510        element->EnthalpyToThermal(&temperature, &waterfraction, enthalpy, pressure);
    15111511
    … …  
    15201520        int         i,rheology_law;
    15211521        IssmDouble  B_average,s_average,T_average=0.,P_average=0.;
    1522         IssmDouble  n=3.0;
    15231522        int        *doflist   = NULL;
    15241523        IssmDouble *xyz_list  = NULL;
    … …  
    15461545
    15471546        /*Get all inputs and parameters*/
    1548         if(element->material->ObjectEnum()!=MatestarEnum) n=element->GetMaterialParameter(MaterialsRheologyNEnum);
    15491547        element->GetInputValue(&converged,ConvergedEnum);
    15501548        element->GetInputListOnNodes(&pressure[0],PressureEnum);
    … …  
    15591557                element->AddInput(TemperatureEnum,temperature,element->GetElementType());
    15601558
     1559                IssmDouble* n = xNew<IssmDouble>(numnodes);
     1560                if(element->material->ObjectEnum()!=MatestarEnum){
     1561                        for(i=0;i<numnodes;i++) n[i]=3.;
     1562                }
     1563                else{
     1564                        element->GetInputListOnNodes(&n[0],MaterialsRheologyNEnum);
     1565                }
     1566
    15611567                /*Update Rheology only if converged (we must make sure that the temperature is below melting point
    15621568                 * otherwise the rheology could be negative*/
    1563                 rheology_law=element->GetIntegerMaterialParameter(MaterialsRheologyLawEnum);
     1569                element->FindParam(&rheology_law,MaterialsRheologyLawEnum);
    15641570                element->GetInputListOnNodes(&surface[0],SurfaceEnum);
    15651571                switch(rheology_law){
    … …  
    15761582                                break;
    15771583                        case CuffeyTemperateEnum:
    1578                                 for(i=0;i<numnodes;i++) B[i]=CuffeyTemperate(temperature[i], waterfraction[i],n);
     1584                                for(i=0;i<numnodes;i++) B[i]=CuffeyTemperate(temperature[i], waterfraction[i],n[i]);
    15791585                                element->AddInput(MaterialsRheologyBEnum,&B[0],element->GetElementType());
    15801586                                break;
    … …  
    15831589                                element->AddInput(MaterialsRheologyBEnum,&B[0],element->GetElementType());
    15841590                                break;
    1585                         case ArrheniusEnum:
     1591                        case ArrheniusEnum:{
    15861592                                element->GetVerticesCoordinates(&xyz_list);
    1587                                 for(i=0;i<numnodes;i++) B[i]=Arrhenius(temperature[i],surface[i]-xyz_list[i*3+2],n);
     1593                                for(i=0;i<numnodes;i++) B[i]=Arrhenius(temperature[i],surface[i]-xyz_list[i*3+2],n[i]);
    15881594                                element->AddInput(MaterialsRheologyBEnum,&B[0],element->GetElementType());
    15891595                                break;
    1590                         case LliboutryDuvalEnum:
    1591                                 for(i=0;i<numnodes;i++) B[i]=LliboutryDuval(values[i],pressure[i],n,element->GetMaterialParameter(MaterialsBetaEnum),element->GetMaterialParameter(ConstantsReferencetemperatureEnum),element->GetMaterialParameter(MaterialsHeatcapacityEnum),element->GetMaterialParameter(MaterialsLatentheatEnum));
     1596                                }
     1597                        case LliboutryDuvalEnum:{
     1598                                for(i=0;i<numnodes;i++) B[i]=LliboutryDuval(values[i],pressure[i],n[i],element->FindParam(MaterialsBetaEnum),element->FindParam(ConstantsReferencetemperatureEnum),element->FindParam(MaterialsHeatcapacityEnum),element->FindParam(MaterialsLatentheatEnum));
    15921599                                element->AddInput(MaterialsRheologyBEnum,&B[0],element->GetElementType());
    15931600                                break;
     1601                                }
    15941602                        default: _error_("Rheology law " << EnumToStringx(rheology_law) << " not supported yet");
    15951603                }
     1604                xDelete<IssmDouble>(n);
    15961605        }
    15971606        else{
    … …  
    16241633IssmDouble     EnthalpyAnalysis::PureIceEnthalpy(Element* element,IssmDouble pressure){/*{{{*/
    16251634
    1626         IssmDouble heatcapacity         = element->GetMaterialParameter(MaterialsHeatcapacityEnum);
    1627         IssmDouble referencetemperature = element->GetMaterialParameter(ConstantsReferencetemperatureEnum);
     1635        IssmDouble heatcapacity         = element->FindParam(MaterialsHeatcapacityEnum);
     1636        IssmDouble referencetemperature = element->FindParam(ConstantsReferencetemperatureEnum);
    16281637
    16291638        return heatcapacity*(TMeltingPoint(element,pressure)-referencetemperature);
    … …  
    16311640IssmDouble     EnthalpyAnalysis::TMeltingPoint(Element* element,IssmDouble pressure){/*{{{*/
    16321641
    1633         IssmDouble meltingpoint = element->GetMaterialParameter(MaterialsMeltingpointEnum);
    1634         IssmDouble beta         = element->GetMaterialParameter(MaterialsBetaEnum);
     1642        IssmDouble meltingpoint = element->FindParam(MaterialsMeltingpointEnum);
     1643        IssmDouble beta         = element->FindParam(MaterialsBetaEnum);
    16351644
    16361645        return meltingpoint-beta*pressure;

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

    r23629 r23644  
    546546                IssmDouble* thickness     = xNew<IssmDouble>(numnodes);
    547547                IssmDouble* B             = xNew<IssmDouble>(numnodes);
     548                IssmDouble* n             = xNew<IssmDouble>(numnodes);
    548549                IssmDouble* eplhead       = xNew<IssmDouble>(numnodes);
    549550                IssmDouble* epl_slopeX    = xNew<IssmDouble>(numnodes);
    … …  
    559560
    560561                /*For now, assuming just one way to compute EPL thickness*/
    561                 IssmDouble gravity          = element->GetMaterialParameter(ConstantsGEnum);
    562                 IssmDouble rho_water        = element->GetMaterialParameter(MaterialsRhoFreshwaterEnum);
    563                 IssmDouble rho_ice          = element->GetMaterialParameter(MaterialsRhoIceEnum);
    564                 IssmDouble n                =   element->GetMaterialParameter(MaterialsRheologyNEnum);
    565                 IssmDouble latentheat       = element->GetMaterialParameter(MaterialsLatentheatEnum);
    566                 IssmDouble epl_conductivity = element->GetMaterialParameter(HydrologydcEplConductivityEnum);
    567                 IssmDouble init_thick       =   element->GetMaterialParameter(HydrologydcEplInitialThicknessEnum);
    568                 IssmDouble max_thick        =   element->GetMaterialParameter(HydrologydcEplMaxThicknessEnum);
     562                IssmDouble gravity          = element->FindParam(ConstantsGEnum);
     563                IssmDouble rho_water        = element->FindParam(MaterialsRhoFreshwaterEnum);
     564                IssmDouble rho_ice          = element->FindParam(MaterialsRhoIceEnum);
     565                IssmDouble latentheat       = element->FindParam(MaterialsLatentheatEnum);
     566                IssmDouble epl_conductivity = element->FindParam(HydrologydcEplConductivityEnum);
     567                IssmDouble init_thick       =   element->FindParam(HydrologydcEplInitialThicknessEnum);
     568                IssmDouble max_thick        =   element->FindParam(HydrologydcEplMaxThicknessEnum);
    569569
    570570                switch(domaintype){
    … …  
    580580                element->GetInputListOnVertices(&ice_thickness[0],ThicknessEnum);
    581581                element->GetInputListOnVertices(&bed[0],BaseEnum);
     582                element->GetInputListOnVertices(&n[0],MaterialsRheologyNEnum);
    582583
    583584                if(!active_element){
    … …  
    589590                else{
    590591                        for(int i=0;i<numnodes;i++){
    591                                 A=pow(B[i],-n);
     592                                A=pow(B[i],-n[i]);
    592593                                /*Compute first the effective pressure in the EPL*/
    593594                                EPL_N=gravity*((rho_ice*ice_thickness[i])-(rho_water*(eplhead[i]-bed[i])));
    … …  
    597598                                /*And proceed to the real thing*/
    598599                                opening=(rho_water*gravity*epl_conductivity*EPLgrad2*dt)/(rho_ice*latentheat);
    599                                 closing=(2.0*A*dt*pow(EPL_N,n))/(pow(n,n));
     600                                closing=(2.0*A*dt*pow(EPL_N,n[i]))/(pow(n[i],n[i]));
    600601                                /*implicit*/
    601602                                thickness[i] = old_thickness[i]/(1.0-opening+closing);
    … …  
    619620                xDelete<IssmDouble>(bed);
    620621                xDelete<IssmDouble>(B);
     622                xDelete<IssmDouble>(n);
    621623        }
    622624}/*}}}*/
    … …  
    679681        IssmDouble* base          =xNew<IssmDouble>(numnodes);
    680682
    681         IssmDouble init_thick    =basalelement->GetMaterialParameter(HydrologydcEplInitialThicknessEnum);
    682         IssmDouble colapse_thick =basalelement->GetMaterialParameter(HydrologydcEplColapseThicknessEnum);
     683        IssmDouble init_thick    =basalelement->FindParam(HydrologydcEplInitialThicknessEnum);
     684        IssmDouble colapse_thick =basalelement->FindParam(HydrologydcEplColapseThicknessEnum);
    683685
    684686        Input* active_element_input=basalelement->GetInput(HydrologydcMaskEplactiveEltEnum); _assert_(active_element_input);
    … …  
    749751        IssmDouble water_sheet,storing;
    750752        IssmDouble epl_thickness,prestep_head,base_elev;
    751         IssmDouble rho_freshwater        = element->GetMaterialParameter(MaterialsRhoFreshwaterEnum);
    752         IssmDouble g                     = element->GetMaterialParameter(ConstantsGEnum);
    753         IssmDouble epl_porosity                                  = element->GetMaterialParameter(HydrologydcEplPorosityEnum);
    754         IssmDouble epl_compressibility   = element->GetMaterialParameter(HydrologydcEplCompressibilityEnum);
    755         IssmDouble water_compressibility = element->GetMaterialParameter(HydrologydcWaterCompressibilityEnum);
     753        IssmDouble rho_freshwater        = element->FindParam(MaterialsRhoFreshwaterEnum);
     754        IssmDouble g                     = element->FindParam(ConstantsGEnum);
     755        IssmDouble epl_porosity                                  = element->FindParam(HydrologydcEplPorosityEnum);
     756        IssmDouble epl_compressibility   = element->FindParam(HydrologydcEplCompressibilityEnum);
     757        IssmDouble water_compressibility = element->FindParam(HydrologydcWaterCompressibilityEnum);
    756758
    757759        epl_thick_input->GetInputValue(&epl_thickness,gauss);
    … …  
    781783        IssmDouble water_sheet;
    782784        IssmDouble epl_thickness,base_elev,prestep_head;
    783         IssmDouble epl_conductivity      = element->GetMaterialParameter(HydrologydcEplConductivityEnum);
     785        IssmDouble epl_conductivity      = element->FindParam(HydrologydcEplConductivityEnum);
    784786        epl_thick_input->GetInputValue(&epl_thickness,gauss);
    785787        epl_head_input->GetInputValue(&prestep_head,gauss);
    … …  
    861863        case 2:
    862864                /*Compute max*/
    863                 rho_water = element->GetMaterialParameter(MaterialsRhoFreshwaterEnum);
    864                 rho_ice   = element->GetMaterialParameter(MaterialsRhoIceEnum);
     865                rho_water = element->FindParam(MaterialsRhoFreshwaterEnum);
     866                rho_ice   = element->FindParam(MaterialsRhoIceEnum);
    865867                element-> GetInputValue(&thickness,innode,ThicknessEnum);
    866868                element-> GetInputValue(&bed,innode,BaseEnum);

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

    r23629 r23644  
    536536                basalelement->FindParam(&kmax,HydrologySedimentKmaxEnum);
    537537                basalelement->FindParam(&penalty_factor,HydrologydcPenaltyFactorEnum);
    538                 IssmDouble rho_freshwater = basalelement->GetMaterialParameter(MaterialsRhoFreshwaterEnum);
    539                 IssmDouble rho_ice        = basalelement->GetMaterialParameter(MaterialsRhoIceEnum);
    540                 IssmDouble g              = basalelement->GetMaterialParameter(ConstantsGEnum);
     538                IssmDouble rho_freshwater = basalelement->FindParam(MaterialsRhoFreshwaterEnum);
     539                IssmDouble rho_ice        = basalelement->FindParam(MaterialsRhoIceEnum);
     540                IssmDouble g              = basalelement->FindParam(ConstantsGEnum);
    541541
    542542                basalelement->GetInputListOnVertices(thickness,ThicknessEnum);
    … …  
    595595        IssmDouble storing,yield;
    596596        IssmDouble base_elev,prestep_head,water_sheet;
    597         IssmDouble rho_freshwater           = element->GetMaterialParameter(MaterialsRhoFreshwaterEnum);
    598         IssmDouble g                        = element->GetMaterialParameter(ConstantsGEnum);
    599         IssmDouble sediment_porosity        = element->GetMaterialParameter(HydrologydcSedimentPorosityEnum);
    600         IssmDouble sediment_thickness       = element->GetMaterialParameter(HydrologydcSedimentThicknessEnum);
    601         IssmDouble sediment_compressibility = element->GetMaterialParameter(HydrologydcSedimentCompressibilityEnum);
    602         IssmDouble water_compressibility    = element->GetMaterialParameter(HydrologydcWaterCompressibilityEnum);
     597        IssmDouble rho_freshwater           = element->FindParam(MaterialsRhoFreshwaterEnum);
     598        IssmDouble g                        = element->FindParam(ConstantsGEnum);
     599        IssmDouble sediment_porosity        = element->FindParam(HydrologydcSedimentPorosityEnum);
     600        IssmDouble sediment_thickness       = element->FindParam(HydrologydcSedimentThicknessEnum);
     601        IssmDouble sediment_compressibility = element->FindParam(HydrologydcSedimentCompressibilityEnum);
     602        IssmDouble water_compressibility    = element->FindParam(HydrologydcWaterCompressibilityEnum);
    603603        element->FindParam(&unconf_scheme,HydrologydcUnconfinedFlagEnum);
    604604        switch(unconf_scheme){
    … …  
    636636        IssmDouble groundedice;
    637637        IssmDouble base_elev,prestep_head,water_sheet;
    638         IssmDouble sediment_thickness       = element->GetMaterialParameter(HydrologydcSedimentThicknessEnum);
     638        IssmDouble sediment_thickness       = element->FindParam(HydrologydcSedimentThicknessEnum);
    639639
    640640        element->FindParam(&unconf_scheme,HydrologydcUnconfinedFlagEnum);
    … …  
    681681        case 2:
    682682                /*Compute max*/
    683                 rho_water = element->GetMaterialParameter(MaterialsRhoFreshwaterEnum);
    684                 rho_ice   = element->GetMaterialParameter(MaterialsRhoIceEnum);
     683                rho_water = element->FindParam(MaterialsRhoFreshwaterEnum);
     684                rho_ice   = element->FindParam(MaterialsRhoIceEnum);
    685685                element->GetInputValue(&thickness,innode,ThicknessEnum);
    686686                element->GetInputValue(&bed,innode,BaseEnum);

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

    r23585 r23644  
    108108        /*Retrieve all inputs and parameters*/
    109109        element->FindParam(&dt,TimesteppingTimeStepEnum);
    110         IssmDouble  rho_ice   = element->GetMaterialParameter(MaterialsRhoIceEnum);
    111         IssmDouble  rho_water = element->GetMaterialParameter(MaterialsRhoFreshwaterEnum);
     110        IssmDouble  rho_ice   = element->FindParam(MaterialsRhoIceEnum);
     111        IssmDouble  rho_water = element->FindParam(MaterialsRhoFreshwaterEnum);
    112112
    113113        /*Get water column and drainage rate*/

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

    r23629 r23644  
    241241        /*Retrieve all inputs and parameters*/
    242242        element->GetVerticesCoordinates(&xyz_list);
    243         IssmDouble  latentheat      = element->GetMaterialParameter(MaterialsLatentheatEnum);
    244         IssmDouble  g               = element->GetMaterialParameter(ConstantsGEnum);
    245         IssmDouble  rho_ice         = element->GetMaterialParameter(MaterialsRhoIceEnum);
    246         IssmDouble  rho_water       = element->GetMaterialParameter(MaterialsRhoFreshwaterEnum);
     243        IssmDouble  latentheat      = element->FindParam(MaterialsLatentheatEnum);
     244        IssmDouble  g               = element->FindParam(ConstantsGEnum);
     245        IssmDouble  rho_ice         = element->FindParam(MaterialsRhoIceEnum);
     246        IssmDouble  rho_water       = element->FindParam(MaterialsRhoFreshwaterEnum);
    247247        Input* geothermalflux_input = element->GetInput(BasalforcingsGeothermalfluxEnum);_assert_(geothermalflux_input);
    248248        Input* head_input           = element->GetInput(HydrologyHeadEnum);              _assert_(head_input);
    … …  
    355355
    356356        /*Get gravity from parameters*/
    357            IssmDouble  g = element->GetMaterialParameter(ConstantsGEnum);
     357           IssmDouble  g = element->FindParam(ConstantsGEnum);
    358358
    359359        /*Fetch number of nodes for this finite element*/
    … …  
    368368        IssmDouble* thickness = xNew<IssmDouble>(numnodes);
    369369        IssmDouble* bed       = xNew<IssmDouble>(numnodes);
    370         IssmDouble  rho_ice   = element->GetMaterialParameter(MaterialsRhoIceEnum);
    371         IssmDouble  rho_water = element->GetMaterialParameter(MaterialsRhoFreshwaterEnum);
     370        IssmDouble  rho_ice   = element->FindParam(MaterialsRhoIceEnum);
     371        IssmDouble  rho_water = element->FindParam(MaterialsRhoFreshwaterEnum);
    372372        element->GetInputListOnNodes(&thickness[0],ThicknessEnum);
    373373        element->GetInputListOnNodes(&bed[0],BaseEnum);
    … …  
    437437
    438438        /*Get gravity from parameters*/
    439         IssmDouble  g = element->GetMaterialParameter(ConstantsGEnum);
     439        IssmDouble  g = element->FindParam(ConstantsGEnum);
    440440
    441441        /*Get Reynolds and gap average values*/
    … …  
    479479        element->GetVerticesCoordinates(&xyz_list);
    480480        element->FindParam(&dt,TimesteppingTimeStepEnum);
    481         IssmDouble  latentheat      = element->GetMaterialParameter(MaterialsLatentheatEnum);
    482         IssmDouble  g               = element->GetMaterialParameter(ConstantsGEnum);
    483         IssmDouble  rho_ice         = element->GetMaterialParameter(MaterialsRhoIceEnum);
    484         IssmDouble  rho_water       = element->GetMaterialParameter(MaterialsRhoFreshwaterEnum);
     481        IssmDouble  latentheat      = element->FindParam(MaterialsLatentheatEnum);
     482        IssmDouble  g               = element->FindParam(ConstantsGEnum);
     483        IssmDouble  rho_ice         = element->FindParam(MaterialsRhoIceEnum);
     484        IssmDouble  rho_water       = element->FindParam(MaterialsRhoFreshwaterEnum);
    485485        Input* geothermalflux_input = element->GetInput(BasalforcingsGeothermalfluxEnum);_assert_(geothermalflux_input);
    486486        Input* head_input           = element->GetInput(HydrologyHeadEnum);              _assert_(head_input);

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

    r23629 r23644  
    105105
    106106        /*Retrieve all inputs and parameters*/
    107         IssmDouble  rho_ice   = element->GetMaterialParameter(MaterialsRhoIceEnum);
    108         IssmDouble  rho_water = element->GetMaterialParameter(MaterialsRhoSeawaterEnum);
    109         IssmDouble  g         = element->GetMaterialParameter(ConstantsGEnum);
    110         IssmDouble  mu_water  = element->GetMaterialParameter(MaterialsMuWaterEnum);
     107        IssmDouble  rho_ice   = element->FindParam(MaterialsRhoIceEnum);
     108        IssmDouble  rho_water = element->FindParam(MaterialsRhoSeawaterEnum);
     109        IssmDouble  g         = element->FindParam(ConstantsGEnum);
     110        IssmDouble  mu_water  = element->FindParam(MaterialsMuWaterEnum);
    111111        Input* surfaceslopex_input = element->GetInput(SurfaceSlopeXEnum); _assert_(surfaceslopex_input);
    112112        Input* surfaceslopey_input = element->GetInput(SurfaceSlopeYEnum); _assert_(surfaceslopey_input);

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

    r23607 r23644  
    719719                        Element* element  = xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    720720
    721                         rho_ice = element->GetMaterialParameter(MaterialsRhoIceEnum);
    722                         rho_water = element->GetMaterialParameter(MaterialsRhoSeawaterEnum);
     721                        rho_ice = element->FindParam(MaterialsRhoIceEnum);
     722                        rho_water = element->FindParam(MaterialsRhoSeawaterEnum);
    723723
    724724                        int      numnodes           = element->GetNumberOfNodes();

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

    r23629 r23644  
    750750        /*Find MasstransportHydrostaticAdjustment to figure out how to update the geometry:*/
    751751        basalelement->FindParam(&hydroadjustment,MasstransportHydrostaticAdjustmentEnum);
    752         rho_ice   = basalelement->GetMaterialParameter(MaterialsRhoIceEnum);
    753         rho_water = basalelement->GetMaterialParameter(MaterialsRhoSeawaterEnum);
     752        rho_ice   = basalelement->FindParam(MaterialsRhoIceEnum);
     753        rho_water = basalelement->FindParam(MaterialsRhoSeawaterEnum);
    754754
    755755        for(i=0;i<numnodes;i++) {

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

    r23585 r23644  
    9797        /*Retrieve all inputs and parameters*/
    9898        basalelement->GetVerticesCoordinates(&xyz_list);
    99         IssmDouble latentheat   = element->GetMaterialParameter(MaterialsLatentheatEnum);
    100         IssmDouble heatcapacity = element->GetMaterialParameter(MaterialsHeatcapacityEnum);
     99        IssmDouble latentheat   = element->FindParam(MaterialsLatentheatEnum);
     100        IssmDouble heatcapacity = element->FindParam(MaterialsHeatcapacityEnum);
    101101
    102102        /* Start  looping on the number of gaussian points: */

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

    r23585 r23644  
    137137                case DrivingStressXEnum:
    138138                case DrivingStressYEnum:{
    139                         rho_ice       = element->GetMaterialParameter(MaterialsRhoIceEnum);
    140                         gravity       = element->GetMaterialParameter(ConstantsGEnum);
     139                        rho_ice       = element->FindParam(MaterialsRhoIceEnum);
     140                        gravity       = element->FindParam(ConstantsGEnum);
    141141                        H_input       = element->GetInput(ThicknessEnum); _assert_(H_input);
    142142                        surface_input = element->GetInput(SurfaceEnum);   _assert_(surface_input);

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

    r23629 r23644  
    16341634        Input*     thickness_input=element->GetInput(ThicknessEnum); _assert_(thickness_input);
    16351635        Input*     surface_input  =element->GetInput(SurfaceEnum);   _assert_(surface_input);
    1636         IssmDouble rhog = element->GetMaterialParameter(MaterialsRhoIceEnum)*element->GetMaterialParameter(ConstantsGEnum);
     1636        IssmDouble rhog = element->FindParam(MaterialsRhoIceEnum)*element->FindParam(ConstantsGEnum);
    16371637
    16381638        /* Start  looping on the number of gaussian points: */
    … …  
    16991699        Input* base_input       = element->GetInput(BaseEnum);       _assert_(base_input);
    17001700        Input* sealevel_input       = element->GetInput(SealevelEnum);       _assert_(sealevel_input);
    1701         IssmDouble rho_water   = element->GetMaterialParameter(MaterialsRhoSeawaterEnum);
    1702         IssmDouble rho_ice     = element->GetMaterialParameter(MaterialsRhoIceEnum);
    1703         IssmDouble gravity     = element->GetMaterialParameter(ConstantsGEnum);
     1701        IssmDouble rho_water   = element->FindParam(MaterialsRhoSeawaterEnum);
     1702        IssmDouble rho_ice     = element->FindParam(MaterialsRhoIceEnum);
     1703        IssmDouble gravity     = element->FindParam(ConstantsGEnum);
    17041704        element->GetVerticesCoordinates(&xyz_list);
    17051705        element->GetIcefrontCoordinates(&xyz_list_front,xyz_list,MaskIceLevelsetEnum);
    … …  
    18711871
    18721872        element->FindParam(&domaintype,DomainTypeEnum);
    1873         rho_ice =element->GetMaterialParameter(MaterialsRhoIceEnum);
    1874         g       =element->GetMaterialParameter(ConstantsGEnum);
     1873        rho_ice =element->FindParam(MaterialsRhoIceEnum);
     1874        g       =element->FindParam(ConstantsGEnum);
    18751875        switch(domaintype){
    18761876                case Domain2DhorizontalEnum:
    … …  
    21032103        Input*     thickness_input=element->GetInput(ThicknessEnum); _assert_(thickness_input);
    21042104        Input*     surface_input  =element->GetInput(SurfaceEnum);   _assert_(surface_input);
    2105         IssmDouble rhog = element->GetMaterialParameter(MaterialsRhoIceEnum)*element->GetMaterialParameter(ConstantsGEnum);
     2105        IssmDouble rhog = element->FindParam(MaterialsRhoIceEnum)*element->FindParam(ConstantsGEnum);
    21062106
    21072107        /* Start  looping on the number of gaussian points: */
    … …  
    21552155        Input* base_input       = element->GetInput(BaseEnum);       _assert_(base_input);
    21562156        Input* sealevel_input       = element->GetInput(SealevelEnum);       _assert_(sealevel_input);
    2157         IssmDouble rho_water   = element->GetMaterialParameter(MaterialsRhoSeawaterEnum);
    2158         IssmDouble rho_ice     = element->GetMaterialParameter(MaterialsRhoIceEnum);
    2159         IssmDouble gravity     = element->GetMaterialParameter(ConstantsGEnum);
     2157        IssmDouble rho_water   = element->FindParam(MaterialsRhoSeawaterEnum);
     2158        IssmDouble rho_ice     = element->FindParam(MaterialsRhoIceEnum);
     2159        IssmDouble gravity     = element->FindParam(ConstantsGEnum);
    21602160        element->GetVerticesCoordinates(&xyz_list);
    21612161        element->GetIcefrontCoordinates(&xyz_list_front,xyz_list,MaskIceLevelsetEnum);
    … …  
    22112211        element->FindParam(&dim,DomainDimensionEnum);
    22122212        element->FindParam(&domaintype,DomainTypeEnum);
    2213         rho_ice =element->GetMaterialParameter(MaterialsRhoIceEnum);
    2214         g       =element->GetMaterialParameter(ConstantsGEnum);
     2213        rho_ice =element->FindParam(MaterialsRhoIceEnum);
     2214        g       =element->FindParam(ConstantsGEnum);
    22152215        if(dim==2){
    22162216                element->GetInputListOnVertices(thickness,ThicknessEnum);
    … …  
    26302630        element->GetVerticesCoordinates(&xyz_list);
    26312631        Input*     surface_input = element->GetInput(SurfaceEnum);   _assert_(surface_input);
    2632         IssmDouble rhog = element->GetMaterialParameter(MaterialsRhoIceEnum)*element->GetMaterialParameter(ConstantsGEnum);
     2632        IssmDouble rhog = element->FindParam(MaterialsRhoIceEnum)*element->FindParam(ConstantsGEnum);
    26332633
    26342634        /* Start  looping on the number of gaussian points: */
    … …  
    26872687        Input* surface_input = element->GetInput(SurfaceEnum); _assert_(surface_input);
    26882688        Input* sealevel_input       = element->GetInput(SealevelEnum);       _assert_(sealevel_input);
    2689         IssmDouble rho_water = element->GetMaterialParameter(MaterialsRhoSeawaterEnum);
    2690         IssmDouble rho_ice   = element->GetMaterialParameter(MaterialsRhoIceEnum);
    2691         IssmDouble gravity   = element->GetMaterialParameter(ConstantsGEnum);
     2689        IssmDouble rho_water = element->FindParam(MaterialsRhoSeawaterEnum);
     2690        IssmDouble rho_ice   = element->FindParam(MaterialsRhoIceEnum);
     2691        IssmDouble gravity   = element->FindParam(ConstantsGEnum);
    26922692        element->GetVerticesCoordinates(&xyz_list);
    26932693        element->GetIcefrontCoordinates(&xyz_list_front,xyz_list,MaskIceLevelsetEnum);
    … …  
    28732873
    28742874        element->FindParam(&domaintype,DomainTypeEnum);
    2875         IssmDouble rho_ice =element->GetMaterialParameter(MaterialsRhoIceEnum);
    2876         IssmDouble g       =element->GetMaterialParameter(ConstantsGEnum);
     2875        IssmDouble rho_ice =element->FindParam(MaterialsRhoIceEnum);
     2876        IssmDouble g       =element->FindParam(ConstantsGEnum);
    28772877        switch(domaintype){
    28782878                case Domain3DEnum:
    … …  
    31243124        element->FindParam(&dt,TimesteppingTimeStepEnum);
    31253125        if(dt==0)   dt=1.e+5;
    3126         IssmDouble  rho_water     = element->GetMaterialParameter(MaterialsRhoSeawaterEnum);
    3127         IssmDouble  gravity       = element->GetMaterialParameter(ConstantsGEnum);
     3126        IssmDouble  rho_water     = element->FindParam(MaterialsRhoSeawaterEnum);
     3127        IssmDouble  gravity       = element->FindParam(ConstantsGEnum);
    31283128        Input*      base_input = element->GetInput(BaseEnum); _assert_(base_input);
    31293129
    … …  
    40184018        /*Retrieve all inputs and parameters*/
    40194019        element->GetVerticesCoordinates(&xyz_list);
    4020         IssmDouble  rho_ice =element->GetMaterialParameter(MaterialsRhoIceEnum);
    4021         IssmDouble  gravity =element->GetMaterialParameter(ConstantsGEnum);
     4020        IssmDouble  rho_ice =element->FindParam(MaterialsRhoIceEnum);
     4021        IssmDouble  gravity =element->FindParam(ConstantsGEnum);
    40224022        Input*      loadingforcex_input=element->GetInput(LoadingforceXEnum);  _assert_(loadingforcex_input);
    40234023        Input*      loadingforcey_input=element->GetInput(LoadingforceYEnum);  _assert_(loadingforcey_input);
    … …  
    41004100        Input* surface_input  = element->GetInput(SurfaceEnum); _assert_(surface_input);
    41014101        Input* sealevel_input       = element->GetInput(SealevelEnum);       _assert_(sealevel_input);
    4102         IssmDouble  rho_water = element->GetMaterialParameter(MaterialsRhoSeawaterEnum);
    4103         IssmDouble  gravity   = element->GetMaterialParameter(ConstantsGEnum);
     4102        IssmDouble  rho_water = element->FindParam(MaterialsRhoSeawaterEnum);
     4103        IssmDouble  gravity   = element->FindParam(ConstantsGEnum);
    41044104
    41054105        /*Initialize gauss points*/
    … …  
    41684168        element->GetVerticesCoordinatesBase(&xyz_list_base);
    41694169        Input*      base_input=element->GetInput(BaseEnum); _assert_(base_input);
    4170         IssmDouble  rho_water=element->GetMaterialParameter(MaterialsRhoSeawaterEnum);
    4171         IssmDouble  gravity  =element->GetMaterialParameter(ConstantsGEnum);
     4170        IssmDouble  rho_water=element->FindParam(MaterialsRhoSeawaterEnum);
     4171        IssmDouble  gravity  =element->FindParam(ConstantsGEnum);
    41724172
    41734173        /* Start  looping on the number of gaussian points: */
    … …  
    73247324        /*For pressure: we have not computed pressure in this analysis, for this element. We are in 2D,
    73257325         *so the pressure is just the pressure at the bedrock: */
    7326         rho_ice = element->GetMaterialParameter(MaterialsRhoIceEnum);
    7327         g       = element->GetMaterialParameter(ConstantsGEnum);
     7326        rho_ice = element->FindParam(MaterialsRhoIceEnum);
     7327        g       = element->FindParam(ConstantsGEnum);
    73287328        element->GetVerticesCoordinates(&xyz_list);
    73297329        element->GetInputListOnNodes(&surface[0],SurfaceEnum);

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

    r23629 r23644  
    318318
    319319        /*Retrieve all inputs and parameters*/
    320         IssmDouble  rho_ice    = element->GetMaterialParameter(MaterialsRhoIceEnum);
    321         IssmDouble  gravity    = element->GetMaterialParameter(ConstantsGEnum);
    322         IssmDouble  n          = element->GetMaterialParameter(MaterialsRheologyNEnum);
    323         IssmDouble B;
     320        IssmDouble  rho_ice    = element->FindParam(MaterialsRhoIceEnum);
     321        IssmDouble  gravity    = element->FindParam(ConstantsGEnum);
     322        IssmDouble  B,n;
    324323        Input* B_input         = element->GetInput(MaterialsRheologyBbarEnum);_assert_(B_input);
     324        Input* n_input         = element->GetInput(MaterialsRheologyNEnum);   _assert_(n_input);
    325325        Input* slopex_input    = element->GetInput(SurfaceSlopeXEnum);        _assert_(slopex_input);
    326326        Input* slopey_input    = element->GetInput(SurfaceSlopeYEnum);        _assert_(slopey_input);
    … …  
    339339
    340340                B_input->GetInputValue(&B,gauss);
     341                n_input->GetInputValue(&n,gauss);
    341342                thickness_input->GetInputValue(&thickness,gauss);
    342343                surface_input->GetInputValue(&surface,gauss);
    … …  
    407408        /*Retrieve all inputs and parameters*/
    408409        element->GetVerticesCoordinates(&xyz_list);
    409         IssmDouble  rho_ice    = element->GetMaterialParameter(MaterialsRhoIceEnum);
    410         IssmDouble  gravity    = element->GetMaterialParameter(ConstantsGEnum);
    411         IssmDouble  n          = element->GetMaterialParameter(MaterialsRheologyNEnum);
    412         IssmDouble B;
     410        IssmDouble  rho_ice    = element->FindParam(MaterialsRhoIceEnum);
     411        IssmDouble  gravity    = element->FindParam(ConstantsGEnum);
     412        IssmDouble B,n;
    413413        Input* B_input         = element->GetInput(MaterialsRheologyBEnum);   _assert_(B_input);
     414        Input* n_input         = element->GetInput(MaterialsRheologyNEnum);   _assert_(n_input);
    414415        Input* surface_input   = element->GetInput(SurfaceEnum);              _assert_(surface_input);
    415416        Input* slopex_input    = element->GetInput(SurfaceSlopeXEnum);        _assert_(slopex_input);
    … …  
    442443
    443444                        B_input->GetInputValue(&B,gauss);
     445                        n_input->GetInputValue(&n,gauss);
    444446                        slopex_input->GetInputValue(&slope[0],gauss);
    445447                        slopey_input->GetInputValue(&slope[1],gauss);
    … …  
    598600        /*For pressure: we have not computed pressure in this analysis, for this element. We are in 2D,
    599601         *so the pressure is just the pressure at the bedrock: */
    600         rho_ice  = element->GetMaterialParameter(MaterialsRhoIceEnum);
    601         g        = element->GetMaterialParameter(ConstantsGEnum);
     602        rho_ice  = element->FindParam(MaterialsRhoIceEnum);
     603        g        = element->FindParam(ConstantsGEnum);
    602604        element->FindParam(&domaintype,DomainTypeEnum);
    603605        switch(domaintype){

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

    r23629 r23644  
    584584         *so the pressure is just the pressure at the z elevation: except it this is a HOFS element */
    585585        if(approximation!=HOFSApproximationEnum &&  approximation!=SSAFSApproximationEnum){
    586                 rho_ice = element->GetMaterialParameter(MaterialsRhoIceEnum);
    587                 g       = element->GetMaterialParameter(ConstantsGEnum);
     586                rho_ice = element->FindParam(MaterialsRhoIceEnum);
     587                g       = element->FindParam(ConstantsGEnum);
    588588                element->GetInputListOnNodes(&surface[0],SurfaceEnum,0.);
    589589                for(i=0;i<numnodes;i++) pressure[i]=rho_ice*g*(surface[i]-xyz_list[i*3+2]);

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

    r23629 r23644  
    338338        element->GetVerticesCoordinatesBase(&xyz_list_base);
    339339        element->FindParam(&dt,TimesteppingTimeStepEnum);
    340         IssmDouble  gravity             = element->GetMaterialParameter(ConstantsGEnum);
    341         IssmDouble  rho_water           = element->GetMaterialParameter(MaterialsRhoSeawaterEnum);
    342         IssmDouble  rho_ice             = element->GetMaterialParameter(MaterialsRhoIceEnum);
    343         IssmDouble  heatcapacity        = element->GetMaterialParameter(MaterialsHeatcapacityEnum);
    344         IssmDouble  mixed_layer_capacity= element->GetMaterialParameter(MaterialsMixedLayerCapacityEnum);
    345         IssmDouble  thermal_exchange_vel= element->GetMaterialParameter(MaterialsThermalExchangeVelocityEnum);
     340        IssmDouble  gravity             = element->FindParam(ConstantsGEnum);
     341        IssmDouble  rho_water           = element->FindParam(MaterialsRhoSeawaterEnum);
     342        IssmDouble  rho_ice             = element->FindParam(MaterialsRhoIceEnum);
     343        IssmDouble  heatcapacity        = element->FindParam(MaterialsHeatcapacityEnum);
     344        IssmDouble  mixed_layer_capacity= element->FindParam(MaterialsMixedLayerCapacityEnum);
     345        IssmDouble  thermal_exchange_vel= element->FindParam(MaterialsThermalExchangeVelocityEnum);
    346346
    347347        /* Start  looping on the number of gaussian points: */
    … …  
    394394        element->FindParam(&dt,TimesteppingTimeStepEnum);
    395395        element->FindParam(&stabilization,ThermalStabilizationEnum);
    396         IssmDouble  rho_water           = element->GetMaterialParameter(MaterialsRhoSeawaterEnum);
    397         IssmDouble  rho_ice             = element->GetMaterialParameter(MaterialsRhoIceEnum);
    398         IssmDouble  gravity             = element->GetMaterialParameter(ConstantsGEnum);
    399         IssmDouble  heatcapacity        = element->GetMaterialParameter(MaterialsHeatcapacityEnum);
    400         IssmDouble  thermalconductivity = element->GetMaterialParameter(MaterialsThermalconductivityEnum);
     396        IssmDouble  rho_water           = element->FindParam(MaterialsRhoSeawaterEnum);
     397        IssmDouble  rho_ice             = element->FindParam(MaterialsRhoIceEnum);
     398        IssmDouble  gravity             = element->FindParam(ConstantsGEnum);
     399        IssmDouble  heatcapacity        = element->FindParam(MaterialsHeatcapacityEnum);
     400        IssmDouble  thermalconductivity = element->FindParam(MaterialsThermalconductivityEnum);
    401401        IssmDouble  kappa = thermalconductivity/(rho_ice*heatcapacity);
    402402        Input* vx_input  = element->GetInput(VxEnum);     _assert_(vx_input);
    … …  
    538538        Input* vz_input             = element->GetInput(VzEnum);                          _assert_(vz_input);
    539539        Input* geothermalflux_input = element->GetInput(BasalforcingsGeothermalfluxEnum); _assert_(geothermalflux_input);
    540         IssmDouble  rho_ice             = element->GetMaterialParameter(MaterialsRhoIceEnum);
    541         IssmDouble  heatcapacity        = element->GetMaterialParameter(MaterialsHeatcapacityEnum);
     540        IssmDouble  rho_ice             = element->FindParam(MaterialsRhoIceEnum);
     541        IssmDouble  heatcapacity        = element->FindParam(MaterialsHeatcapacityEnum);
    542542
    543543        /*Build friction element, needed later: */
    … …  
    596596        element->FindParam(&dt,TimesteppingTimeStepEnum);
    597597        Input*      pressure_input=element->GetInput(PressureEnum); _assert_(pressure_input);
    598         IssmDouble  gravity             = element->GetMaterialParameter(ConstantsGEnum);
    599         IssmDouble  rho_water           = element->GetMaterialParameter(MaterialsRhoSeawaterEnum);
    600         IssmDouble  rho_ice             = element->GetMaterialParameter(MaterialsRhoIceEnum);
    601         IssmDouble  heatcapacity        = element->GetMaterialParameter(MaterialsHeatcapacityEnum);
    602         IssmDouble  mixed_layer_capacity= element->GetMaterialParameter(MaterialsMixedLayerCapacityEnum);
    603         IssmDouble  thermal_exchange_vel= element->GetMaterialParameter(MaterialsThermalExchangeVelocityEnum);
     598        IssmDouble  gravity             = element->FindParam(ConstantsGEnum);
     599        IssmDouble  rho_water           = element->FindParam(MaterialsRhoSeawaterEnum);
     600        IssmDouble  rho_ice             = element->FindParam(MaterialsRhoIceEnum);
     601        IssmDouble  heatcapacity        = element->FindParam(MaterialsHeatcapacityEnum);
     602        IssmDouble  mixed_layer_capacity= element->FindParam(MaterialsMixedLayerCapacityEnum);
     603        IssmDouble  thermal_exchange_vel= element->FindParam(MaterialsThermalExchangeVelocityEnum);
    604604
    605605        /* Start  looping on the number of gaussian points: */
    … …  
    650650        /*Retrieve all inputs and parameters*/
    651651        element->GetVerticesCoordinates(&xyz_list);
    652         IssmDouble  rho_ice             = element->GetMaterialParameter(MaterialsRhoIceEnum);
    653         IssmDouble  heatcapacity        = element->GetMaterialParameter(MaterialsHeatcapacityEnum);
    654         IssmDouble  thermalconductivity = element->GetMaterialParameter(MaterialsThermalconductivityEnum);
     652        IssmDouble  rho_ice             = element->FindParam(MaterialsRhoIceEnum);
     653        IssmDouble  heatcapacity        = element->FindParam(MaterialsHeatcapacityEnum);
     654        IssmDouble  thermalconductivity = element->FindParam(MaterialsThermalconductivityEnum);
    655655        IssmDouble  kappa = thermalconductivity/(rho_ice*heatcapacity);
    656656        element->FindParam(&dt,TimesteppingTimeStepEnum);
    … …  
    807807        int        *doflist   = NULL;
    808808        IssmDouble *xyz_list  = NULL;
    809         IssmDouble  n=3.0;
    810809        bool        hack      = false;
    811810
    … …  
    842841
    843842        /*Get all inputs and parameters*/
    844         if(element->material->ObjectEnum()!=MatestarEnum) n=element->GetMaterialParameter(MaterialsRheologyNEnum);
    845843        element->GetInputValue(&converged,ConvergedEnum);
    846844        if(converged){
    847845                element->AddInput(TemperatureEnum,values,element->GetElementType());
    848846
     847                IssmDouble* n = xNew<IssmDouble>(numnodes);
     848                if(element->material->ObjectEnum()!=MatestarEnum){
     849                        for(i=0;i<numnodes;i++) n[i]=3.;
     850                }
     851                else{
     852                        element->GetInputListOnNodes(&n[0],MaterialsRheologyNEnum);
     853                }
     854
    849855                /*Update Rheology only if converged (we must make sure that the temperature is below melting point
    850856                 * otherwise the rheology could be negative*/
    851                 rheology_law=element->GetIntegerMaterialParameter(MaterialsRheologyLawEnum);
     857                element->FindParam(&rheology_law,MaterialsRheologyLawEnum);
    852858                element->GetInputListOnNodes(&surface[0],SurfaceEnum);
     859
    853860                switch(rheology_law){
    854861                        case NoneEnum:
    … …  
    869876                        case ArrheniusEnum:{
    870877                                element->GetVerticesCoordinates(&xyz_list);
    871                                 for(i=0;i<numnodes;i++) B[i]=Arrhenius(values[i],surface[i]-xyz_list[i*3+2],n);
     878                                for(i=0;i<numnodes;i++) B[i]=Arrhenius(values[i],surface[i]-xyz_list[i*3+2],n[i]);
    872879                                element->AddInput(MaterialsRheologyBEnum,&B[0],element->GetElementType());
    873880                                break;
    … …  
    876883                                _error_("Rheology law " << EnumToStringx(rheology_law) << " not supported yet");
    877884                }
     885                xDelete<IssmDouble>(n);
    878886        }
    879887        else{

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

    r23629 r23644  
    3232        this->vertices   = NULL;
    3333        this->material   = NULL;
    34         this->matpar     = NULL;
    3534        this->parameters = NULL;
    3635        this->element_type_list=NULL;
    … …  
    403402        else _printf_("material = NULL\n");
    404403
    405         if (matpar) matpar->DeepEcho();
    406         else _printf_("matpar = NULL\n");
    407 
    408404        _printf_("   parameters\n");
    409405        if (parameters) parameters->DeepEcho();
    … …  
    558554
    559555        /*Get some pdd parameters*/
    560         dpermil=this->matpar->GetMaterialParameter(SmbDpermilEnum);
     556        dpermil=this->FindParam(SmbDpermilEnum);
    561557
    562558        this->parameters->FindParam(&isTemperatureScaled,SmbIstemperaturescaledEnum);
    … …  
    681677
    682678        /*Get material parameters :*/
    683         rho_water=this->matpar->GetMaterialParameter(MaterialsRhoSeawaterEnum);
    684         rho_ice=this->matpar->GetMaterialParameter(MaterialsRhoIceEnum);
     679        rho_water=this->FindParam(MaterialsRhoSeawaterEnum);
     680        rho_ice=this->FindParam(MaterialsRhoIceEnum);
    685681
    686682        /*Recover parameters*/
    … …  
    935931        else _printf_("material = NULL\n");
    936932
    937         if (matpar) matpar->Echo();
    938         else _printf_("matpar = NULL\n");
    939 
    940933        _printf_("   parameters\n");
    941934        if (parameters) parameters->Echo();
    … …  
    947940}
    948941/*}}}*/
    949 IssmDouble Element::EnthalpyDiffusionParameter(IssmDouble enthalpy,IssmDouble pressure){/*{{{*/
    950         return matpar->GetEnthalpyDiffusionParameter(enthalpy,pressure);
    951 }/*}}}*/
    952 IssmDouble Element::EnthalpyDiffusionParameterVolume(int numvertices,IssmDouble* enthalpy,IssmDouble* pressure){/*{{{*/
    953         return matpar->GetEnthalpyDiffusionParameterVolume(numvertices,enthalpy,pressure);
    954 }/*}}}*/
    955 void       Element::EnthalpyToThermal(IssmDouble* ptemperature,IssmDouble* pwaterfraction,IssmDouble enthalpy,IssmDouble pressure){/*{{{*/
    956         matpar->EnthalpyToThermal(ptemperature,pwaterfraction,enthalpy,pressure);
    957 }/*}}}*/
    958942void       Element::FindParam(bool* pvalue,int paramenum){/*{{{*/
    959943        this->parameters->FindParam(pvalue,paramenum);
    … …  
    964948void       Element::FindParam(IssmDouble* pvalue,int paramenum){/*{{{*/
    965949        this->parameters->FindParam(pvalue,paramenum);
     950}/*}}}*/
     951IssmDouble Element::FindParam(int paramenum){/*{{{*/
     952        return this->parameters->FindParam(paramenum);
    966953}/*}}}*/
    967954void       Element::FindParam(int** pvalues,int* psize,int paramenum){/*{{{*/
    … …  
    13261313        }
    13271314
    1328 }/*}}}*/
    1329 IssmDouble Element::GetMaterialParameter(int enum_in){/*{{{*/
    1330 
    1331         _assert_(this->matpar);
    1332         switch(enum_in){ // FIXME: change this to material
    1333                 case MaterialsRheologyNEnum:
    1334                         return this->material->GetN();
    1335                 default:
    1336                         return this->matpar->GetMaterialParameter(enum_in);
    1337         }
    1338 }/*}}}*/
    1339 int         Element::GetIntegerMaterialParameter(int enum_in){/*{{{*/
    1340 
    1341         return this->matpar->GetIntegerMaterialParameter(enum_in);
    13421315}/*}}}*/
    13431316void       Element::GetNodesLidList(int* lidlist){/*{{{*/
    … …  
    16781651
    16791652        /*recover ice density: */
    1680         rho_ice=matpar->GetMaterialParameter(MaterialsRhoIceEnum);
     1653        rho_ice=FindParam(MaterialsRhoIceEnum);
    16811654
    16821655        return rho_ice*this->IceVolume(scaled);
    … …  
    23132286        GetInputListOnVertices(&sl[0],SealevelEnum);
    23142287        GetInputListOnVertices(&phi[0],MaskGroundediceLevelsetEnum);
    2315         rho_water   = matpar->GetMaterialParameter(MaterialsRhoSeawaterEnum);
    2316         rho_ice     = matpar->GetMaterialParameter(MaterialsRhoIceEnum);
     2288        rho_water   = FindParam(MaterialsRhoSeawaterEnum);
     2289        rho_ice     = FindParam(MaterialsRhoIceEnum);
    23172290        density     = rho_ice/rho_water;
    23182291
    … …  
    25462519
    25472520        /*Get material parameters :*/
    2548         rho_water=this->matpar->GetMaterialParameter(MaterialsRhoSeawaterEnum);
    2549         rho_ice=this->matpar->GetMaterialParameter(MaterialsRhoIceEnum);
     2521        rho_water=this->FindParam(MaterialsRhoSeawaterEnum);
     2522        rho_ice=this->FindParam(MaterialsRhoIceEnum);
    25502523
    25512524        /*Get some pdd parameters*/
    2552         desfac=this->matpar->GetMaterialParameter(SmbDesfacEnum);
    2553         rlaps=this->matpar->GetMaterialParameter(SmbRlapsEnum);
    2554         rlapslgm=this->matpar->GetMaterialParameter(SmbRlapslgmEnum);
     2525        desfac=this->FindParam(SmbDesfacEnum);
     2526        rlaps=this->FindParam(SmbRlapsEnum);
     2527        rlapslgm=this->FindParam(SmbRlapslgmEnum);
    25552528
    25562529        /*Recover monthly temperatures and precipitation and compute the yearly mean temperatures*/
    … …  
    27332706
    27342707        /*Get material parameters :*/
    2735         rho_water=this->matpar->GetMaterialParameter(MaterialsRhoSeawaterEnum);
    2736         rho_ice=this->matpar->GetMaterialParameter(MaterialsRhoIceEnum);
     2708        rho_water=this->FindParam(MaterialsRhoSeawaterEnum);
     2709        rho_ice=this->FindParam(MaterialsRhoIceEnum);
    27372710
    27382711        /*Get parameters for height corrections*/
    2739         desfac=this->matpar->GetMaterialParameter(SmbDesfacEnum);
    2740         rlaps=this->matpar->GetMaterialParameter(SmbRlapsEnum);
     2712        desfac=this->FindParam(SmbDesfacEnum);
     2713        rlaps=this->FindParam(SmbRlapsEnum);
    27412714
    27422715        /*Recover monthly temperatures and precipitation*/
    … …  
    28732846}
    28742847/*}}}*/
    2875 IssmDouble Element::PureIceEnthalpy(IssmDouble pressure){/*{{{*/
    2876         return this->matpar->PureIceEnthalpy(pressure);
    2877 }/*}}}*/
    28782848void       Element::ResultInterpolation(int* pinterpolation,int* pnodesperelement,int* parray_size, int output_enum){/*{{{*/
    28792849
    … …  
    31233093
    31243094        /*Get material parameters :*/
    3125         rho_water=this->matpar->GetMaterialParameter(MaterialsRhoSeawaterEnum);
    3126         rho_ice=this->matpar->GetMaterialParameter(MaterialsRhoIceEnum);
    3127         desfac=this->matpar->GetMaterialParameter(SmbDesfacEnum);
    3128         rlaps=this->matpar->GetMaterialParameter(SmbRlapsEnum);
    3129         rdl=this->matpar->GetMaterialParameter(SmbRdlEnum);
     3095        rho_water=this->FindParam(MaterialsRhoSeawaterEnum);
     3096        rho_ice=this->FindParam(MaterialsRhoIceEnum);
     3097        desfac=this->FindParam(SmbDesfacEnum);
     3098        rlaps=this->FindParam(SmbRlapsEnum);
     3099        rdl=this->FindParam(SmbRdlEnum);
    31303100
    31313101        /* Retrieve inputs: */
    … …  
    33193289
    33203290        /*Retrieve material properties and parameters:{{{ */
    3321         rho_ice = matpar->GetMaterialParameter(MaterialsRhoIceEnum);
    3322         rho_water = matpar->GetMaterialParameter(MaterialsRhoFreshwaterEnum);
     3291        rho_ice = FindParam(MaterialsRhoIceEnum);
     3292        rho_water = FindParam(MaterialsRhoFreshwaterEnum);
    33233293        parameters->FindParam(&aSnow,SmbASnowEnum);
    33243294        parameters->FindParam(&aIce,SmbAIceEnum);
    … …  
    38723842}
    38733843/*}}}*/
    3874 void       Element::ThermalToEnthalpy(IssmDouble* penthalpy,IssmDouble temperature,IssmDouble waterfraction,IssmDouble pressure){/*{{{*/
    3875         matpar->ThermalToEnthalpy(penthalpy,temperature,waterfraction,pressure);
    3876 }/*}}}*/
    3877 IssmDouble Element::TMeltingPoint(IssmDouble pressure){/*{{{*/
    3878         _assert_(matpar);
    3879         return this->matpar->TMeltingPoint(pressure);
    3880 }/*}}}*/
    38813844IssmDouble Element::TotalFloatingBmb(IssmDouble* mask, bool scaled){/*{{{*/
    38823845
    … …  
    41774140}
    41784141/*}}}*/
     4142
     4143/*Enthalpy*/
     4144void       Element::ThermalToEnthalpy(IssmDouble * penthalpy,IssmDouble temperature,IssmDouble waterfraction,IssmDouble pressure){/*{{{*/
     4145
     4146        /*Ouput*/
     4147        IssmDouble enthalpy;
     4148
     4149        /*Get necessary parameters*/
     4150        IssmDouble latentheat,referencetemperature,heatcapacity;
     4151        parameters->FindParam(&latentheat,MaterialsLatentheatEnum);
     4152        parameters->FindParam(&referencetemperature,ConstantsReferencetemperatureEnum);
     4153        parameters->FindParam(&heatcapacity,MaterialsHeatcapacityEnum);
     4154
     4155        if(temperature<TMeltingPoint(pressure)){
     4156                enthalpy=heatcapacity*(temperature-referencetemperature);
     4157        }
     4158        else{
     4159                enthalpy=PureIceEnthalpy(pressure)+latentheat*waterfraction;
     4160        }
     4161
     4162        /*Assign output pointers:*/
     4163        *penthalpy=enthalpy;
     4164}
     4165/*}}}*/
     4166IssmDouble Element::TMeltingPoint(IssmDouble pressure){/*{{{*/
     4167
     4168        /*Get necessary parameters*/
     4169        IssmDouble beta,meltingpoint;
     4170        parameters->FindParam(&beta,MaterialsBetaEnum);
     4171        parameters->FindParam(&meltingpoint,MaterialsMeltingpointEnum);
     4172
     4173        return meltingpoint-beta*pressure;
     4174}
     4175/*}}}*/
     4176void       Element::EnthalpyToThermal(IssmDouble* ptemperature,IssmDouble* pwaterfraction,IssmDouble enthalpy,IssmDouble pressure){/*{{{*/
     4177
     4178        /*Ouput*/
     4179        IssmDouble temperature,waterfraction;
     4180
     4181        /*Get necessary parameters*/
     4182        IssmDouble latentheat,referencetemperature,heatcapacity;
     4183        parameters->FindParam(&latentheat,MaterialsLatentheatEnum);
     4184        parameters->FindParam(&referencetemperature,ConstantsReferencetemperatureEnum);
     4185        parameters->FindParam(&heatcapacity,MaterialsHeatcapacityEnum);
     4186
     4187        if(enthalpy<PureIceEnthalpy(pressure)){
     4188                temperature=referencetemperature+enthalpy/heatcapacity;
     4189                waterfraction=0.;
     4190        }
     4191        else{
     4192                temperature=TMeltingPoint(pressure);
     4193                waterfraction=(enthalpy-PureIceEnthalpy(pressure))/latentheat;
     4194        }
     4195
     4196        /*Assign output pointers:*/
     4197        *pwaterfraction=waterfraction;
     4198        *ptemperature=temperature;
     4199}
     4200/*}}}*/
     4201IssmDouble Element::EnthalpyDiffusionParameter(IssmDouble enthalpy,IssmDouble pressure){/*{{{*/
     4202
     4203        /*Get necessary parameters*/
     4204        IssmDouble heatcapacity,thermalconductivity,temperateiceconductivity;
     4205        parameters->FindParam(&heatcapacity,MaterialsHeatcapacityEnum);
     4206        parameters->FindParam(&thermalconductivity,MaterialsThermalconductivityEnum);
     4207        parameters->FindParam(&temperateiceconductivity,MaterialsTemperateiceconductivityEnum);
     4208
     4209        if(enthalpy<PureIceEnthalpy(pressure)){
     4210                return thermalconductivity/heatcapacity;
     4211        }
     4212        else{
     4213                return temperateiceconductivity/heatcapacity;
     4214        }
     4215}
     4216/*}}}*/
     4217IssmDouble Element::EnthalpyDiffusionParameterVolume(int numvertices,IssmDouble* enthalpy,IssmDouble* pressure){/*{{{*/
     4218
     4219        IssmDouble  lambda;                 // fraction of cold ice
     4220        IssmDouble  kappa,kappa_c,kappa_t;  //enthalpy conductivities
     4221        IssmDouble  Hc,Ht;
     4222        IssmDouble* PIE   = xNew<IssmDouble>(numvertices);
     4223        IssmDouble* dHpmp = xNew<IssmDouble>(numvertices);
     4224
     4225        for(int iv=0; iv<numvertices; iv++){
     4226                PIE[iv]=PureIceEnthalpy(pressure[iv]);
     4227                dHpmp[iv]=enthalpy[iv]-PIE[iv];
     4228        }
     4229
     4230        bool allequalsign=true;
     4231        if(dHpmp[0]<0){
     4232                for(int iv=1; iv<numvertices;iv++) allequalsign=(allequalsign && (dHpmp[iv]<0));
     4233        }
     4234        else{
     4235                for(int iv=1; iv<numvertices;iv++) allequalsign=(allequalsign && (dHpmp[iv]>=0));
     4236        }
     4237
     4238        if(allequalsign){
     4239                kappa=EnthalpyDiffusionParameter(enthalpy[0], pressure[0]);
     4240        }
     4241        else {
     4242                /* return harmonic mean of thermal conductivities, weighted by fraction of cold/temperate ice,
     4243                        cf Patankar 1980, pp44 */
     4244                kappa_c=EnthalpyDiffusionParameter(PureIceEnthalpy(0.)-1.,0.);
     4245                kappa_t=EnthalpyDiffusionParameter(PureIceEnthalpy(0.)+1.,0.);
     4246                Hc=0.; Ht=0.;
     4247                for(int iv=0; iv<numvertices;iv++){
     4248                        if(enthalpy[iv]<PIE[iv])
     4249                         Hc+=(PIE[iv]-enthalpy[iv]);
     4250                        else
     4251                         Ht+=(enthalpy[iv]-PIE[iv]);
     4252                }
     4253                _assert_((Hc+Ht)>0.);
     4254                lambda = Hc/(Hc+Ht);
     4255                kappa  = 1./(lambda/kappa_c + (1.-lambda)/kappa_t);
     4256        }
     4257
     4258        /*Clean up and return*/
     4259        xDelete<IssmDouble>(PIE);
     4260        xDelete<IssmDouble>(dHpmp);
     4261        return kappa;
     4262}
     4263/*}}}*/
     4264IssmDouble Element::PureIceEnthalpy(IssmDouble pressure){/*{{{*/
     4265
     4266        /*Get necessary parameters*/
     4267        IssmDouble referencetemperature,heatcapacity;
     4268        parameters->FindParam(&referencetemperature,ConstantsReferencetemperatureEnum);
     4269        parameters->FindParam(&heatcapacity,MaterialsHeatcapacityEnum);
     4270
     4271        return heatcapacity*(TMeltingPoint(pressure)-referencetemperature);
     4272}
     4273/*}}}*/

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

    r23629 r23644  
    2323class Materials;
    2424class Material;
    25 class Matpar;
    2625class Inputs;
    2726class Input;
    … …  
    4443                Vertex     **vertices;
    4544                Material    *material;
    46                 Matpar      *matpar;
    4745                Parameters  *parameters;
    4846
    … …  
    7573                void               dViscositydDSSA(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
    7674                void               Echo();
    77                 IssmDouble         EnthalpyDiffusionParameter(IssmDouble enthalpy,IssmDouble pressure);
    78                 IssmDouble         EnthalpyDiffusionParameterVolume(int numvertices,IssmDouble* enthalpy,IssmDouble* pressure);
    79                 void               EnthalpyToThermal(IssmDouble* ptemperature,IssmDouble* pwaterfraction,IssmDouble enthalpy,IssmDouble pressure);
    8075                void               FindParam(bool* pvalue,int paramenum);
    8176                void               FindParam(int* pvalue,int paramenum);
    8277                void               FindParam(IssmDouble* pvalue,int paramenum);
     78                IssmDouble         FindParam(int paramenum);
    8379                void               FindParam(int** pvalues,int* psize,int paramenum);
    8480                IssmDouble         FloatingArea(IssmDouble* mask, bool scaled);
    … …  
    10298                void               GetInputValue(IssmDouble* pvalue,Gauss* gauss,int enum_type);
    10399                void               GetInputsInterpolations(Vector<IssmDouble>* interps);
    104                 IssmDouble         GetMaterialParameter(int enum_in);
    105                 int                GetIntegerMaterialParameter(int enum_in);
    106100                void               GetNodesLidList(int* lidlist);
    107101                void               GetNodesSidList(int* sidlist);
    … …  
    151145                void               PositiveDegreeDay(IssmDouble* pdds,IssmDouble* pds,IssmDouble signorm,bool ismungsm,bool issetpddfac);
    152146                void               PositiveDegreeDaySicopolis(bool isfirnwarming);
    153                 IssmDouble         PureIceEnthalpy(IssmDouble pressure);
    154147                void               ResultInterpolation(int* pinterpolation,int*nodesperelement,int* parray_size, int output_enum);
    155148                void               ResultToPatch(IssmDouble* values,int nodesperelement,int output_enum);
    … …  
    167160                void               StrainRateSSA1d(IssmDouble* epsilon,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input);
    168161                void               StressMaxPrincipalCreateInput(void);
    169                 void               ThermalToEnthalpy(IssmDouble* penthalpy,IssmDouble temperature,IssmDouble waterfraction,IssmDouble pressure);
    170                 IssmDouble         TMeltingPoint(IssmDouble pressure);
    171162                IssmDouble         TotalFloatingBmb(IssmDouble* mask, bool scaled);
    172163                IssmDouble         TotalGroundedBmb(IssmDouble* mask, bool scaled);
    … …  
    193184                void               TransformStiffnessMatrixCoord(ElementMatrix* Ke,int numnodes,int* transformenum_list){_error_("not implemented yet");};/*Tiling only*/
    194185                void               ViscousHeatingCreateInput(void);
     186                void               ThermalToEnthalpy(IssmDouble * penthalpy,IssmDouble temperature,IssmDouble waterfraction,IssmDouble pressure);
     187                IssmDouble         TMeltingPoint(IssmDouble pressure);
     188                void               EnthalpyToThermal(IssmDouble* ptemperature,IssmDouble* pwaterfraction,IssmDouble enthalpy,IssmDouble pressure);
     189                IssmDouble         EnthalpyDiffusionParameter(IssmDouble enthalpy,IssmDouble pressure);
     190                IssmDouble         EnthalpyDiffusionParameterVolume(int numvertices,IssmDouble* enthalpy,IssmDouble* pressure);
     191                IssmDouble         PureIceEnthalpy(IssmDouble pressure);
    195192
    196193

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

    r23532 r23644  
    2121        this->hvertices  = NULL;
    2222        this->hmaterial  = NULL;
    23         this->hmatpar    = NULL;
    2423        this->hneighbors = NULL;
    2524}
    … …  
    3534        delete hvertices;
    3635        delete hmaterial;
    37         delete hmatpar;
    3836        delete hneighbors;
    3937}
    … …  
    4139ElementHook::ElementHook(int in_numanalyses,int element_id,int numvertices,IoModel* iomodel){/*{{{*/
    4240
    43         /*intermediary: */
    44         int matpar_id;
     41        /*retrieve material_id*/
    4542        int material_id;
    46 
    47         /*retrieve material_id: */
    48         matpar_id = iomodel->numberofelements+1;
    49 
    50         /*retrieve material_id*/
    5143        material_id = element_id;
    5244
    … …  
    6153        this->hvertices   = new Hook(&vertex_ids[0],numvertices);
    6254        this->hmaterial   = new Hook(&material_id,1);
    63         this->hmatpar     = new Hook(&matpar_id,1);
    6455        this->hneighbors  = NULL;
    6556
    … …  
    109100                this->hvertices   = new Hook();
    110101                this->hmaterial   = new Hook();
    111                 this->hmatpar     = new Hook();
    112102                if(!hneighbors_null)this->hneighbors  = new Hook();
    113103                else this->hneighbors=NULL;
    … …  
    127117        this->hvertices->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    128118        this->hmaterial->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    129         this->hmatpar->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    130119        if(this->hneighbors)this->hneighbors->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    131120
    … …  
    158147   else _printf_("  hmaterial = NULL\n");
    159148
    160         _printf_("  hmatpar:\n");
    161         if(hmatpar) hmatpar->DeepEcho();
    162    else _printf_("  hmatpar = NULL\n");
    163 
    164149        _printf_("  hneighbors:\n");
    165150        if(hneighbors) hneighbors->DeepEcho();
    … …  
    189174        if(hmaterial) hmaterial->Echo();
    190175   else _printf_("  hmaterial = NULL\n");
    191 
    192         _printf_("  hmatpar:\n");
    193         if(hmatpar) hmatpar->Echo();
    194    else _printf_("  hmatpar = NULL\n");
    195176
    196177        _printf_("  hneighbors:\n");
    … …  
    232213        triahook->hmaterial=NULL;
    233214        triahook->hvertices=(Hook*)this->hvertices->Spawn(indices,2);
    234         triahook->hmatpar=(Hook*)this->hmatpar->copy();
    235215}
    236216/*}}}*/
    … …  
    260240        triahook->hmaterial=NULL;
    261241        triahook->hvertices=(Hook*)this->hvertices->Spawn(indices,3);
    262         triahook->hmatpar=(Hook*)this->hmatpar->copy();
    263 }
    264 /*}}}*/
     242}
     243/*}}}*/

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

    r21508 r23644  
    1616                Hook  *hvertices;     // vertices
    1717                Hook  *hmaterial;     // 1 ice material
    18                 Hook  *hmatpar;       // 1 material parameter
    1918                Hook  *hneighbors;    // 2 elements, first down, second up in 3d only
    2019

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

    r23638 r23644  
    5454        this->vertices          = NULL;
    5555        this->material          = NULL;
    56         this->matpar            = NULL;
    5756        this->verticalneighbors = NULL;
    5857
    … …  
    9392        penta->hvertices = (Hook*)this->hvertices->copy();
    9493        penta->hmaterial = (Hook*)this->hmaterial->copy();
    95         penta->hmatpar   = (Hook*)this->hmatpar->copy();
    9694        if (this->hneighbors) penta->hneighbors = (Hook*)(this->hneighbors->copy());
    9795        else penta->hneighbors = NULL;
    … …  
    116114        penta->vertices = (Vertex**)this->hvertices->deliverp();
    117115        penta->material = (Material*)this->hmaterial->delivers();
    118         penta->matpar   = (Matpar*)this->hmatpar->delivers();
    119116        penta->verticalneighbors = (Penta**)this->hneighbors->deliverp();
    120117
    … …  
    134131        vertices = (Vertex**)this->hvertices->deliverp();
    135132        material = (Material*)this->hmaterial->delivers();
    136         matpar   = (Matpar*)this->hmatpar->delivers();
    137133        verticalneighbors = (Penta**)this->hneighbors->deliverp();
    138134
    … …  
    192188        IssmDouble  calvingrate[NUMVERTICES];
    193189        IssmDouble  lambda1,lambda2,ex,ey,vx,vy,vel;
    194         IssmDouble  B,sigma_vm,sigma_max,sigma_max_floating,sigma_max_grounded;
     190        IssmDouble  B,sigma_vm,sigma_max,sigma_max_floating,sigma_max_grounded,n;
    195191        IssmDouble  epse_2,groundedice,bed;
    196192
    … …  
    209205        Input* bs_input = inputs->GetInput(BaseEnum);                    _assert_(bs_input);
    210206        Input* B_input  = inputs->GetInput(MaterialsRheologyBbarEnum);   _assert_(B_input);
     207        Input* n_input  = inputs->GetInput(MaterialsRheologyNEnum);   _assert_(n_input);
    211208        Input* smax_fl_input = inputs->GetInput(CalvingStressThresholdFloatingiceEnum); _assert_(smax_fl_input);
    212209        Input* smax_gr_input = inputs->GetInput(CalvingStressThresholdGroundediceEnum); _assert_(smax_gr_input);
    213         IssmDouble  n   = this->GetMaterialParameter(MaterialsRheologyNEnum);
    214210
    215211        /* Start looping on the number of vertices: */
    … …  
    220216                /*Get velocity components and thickness*/
    221217                B_input->GetInputValue(&B,gauss);
     218                n_input->GetInputValue(&n,gauss);
    222219                vx_input->GetInputValue(&vx,gauss);
    223220                vy_input->GetInputValue(&vy,gauss);
    … …  
    366363
    367364        /*recovre material parameters: */
    368         rho_ice=matpar->GetMaterialParameter(MaterialsRhoIceEnum);
    369         gravity=matpar->GetMaterialParameter(ConstantsGEnum);
     365        rho_ice=FindParam(MaterialsRhoIceEnum);
     366        gravity=FindParam(ConstantsGEnum);
    370367
    371368        /* Get node coordinates and dof list: */
    … …  
    542539        this->hvertices->configure(verticesin);
    543540        this->hmaterial->configure(materialsin);
    544         this->hmatpar->configure(materialsin);
    545541        this->hneighbors->configure(elementsin);
    546542
    … …  
    550546        this->vertices          = (Vertex**)this->hvertices->deliverp();
    551547        this->material          = (Material*)this->hmaterial->delivers();
    552         this->matpar            = (Matpar*)this->hmatpar->delivers();
    553548        this->verticalneighbors = (Penta**)this->hneighbors->deliverp();
    554549
    … …  
    762757        GetInputListOnVertices(&pressure[0],PressureEnum);
    763758        GetInputListOnVertices(&phi[0],MaskGroundediceLevelsetEnum);
    764         IssmDouble rho_ice   = matpar->GetMaterialParameter(MaterialsRhoIceEnum);
    765         IssmDouble rho_water = matpar->GetMaterialParameter(MaterialsRhoSeawaterEnum);
    766         IssmDouble gravity   = matpar->GetMaterialParameter(ConstantsGEnum);
     759        IssmDouble rho_ice   = FindParam(MaterialsRhoIceEnum);
     760        IssmDouble rho_water = FindParam(MaterialsRhoSeawaterEnum);
     761        IssmDouble gravity   = FindParam(ConstantsGEnum);
    767762
    768763        /* Get node coordinates and dof list: */
    … …  
    13311326        if(!IsIceInElement() || IsFloating() || !IsOnBase())return 0;
    13321327
    1333         rho_ice=matpar->GetMaterialParameter(MaterialsRhoIceEnum);
    1334         rho_water=matpar->GetMaterialParameter(MaterialsRhoSeawaterEnum);
     1328        rho_ice=FindParam(MaterialsRhoIceEnum);
     1329        rho_water=FindParam(MaterialsRhoSeawaterEnum);
    13351330        ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    13361331
    … …  
    21292124
    21302125        /*material parameters: */
    2131         rho_water=matpar->GetMaterialParameter(MaterialsRhoSeawaterEnum);
    2132         rho_ice=matpar->GetMaterialParameter(MaterialsRhoIceEnum);
     2126        rho_water=FindParam(MaterialsRhoSeawaterEnum);
     2127        rho_ice=FindParam(MaterialsRhoIceEnum);
    21332128        density=rho_ice/rho_water;
    21342129        GetInputListOnVertices(&h[0],ThicknessEnum);
    … …  
    22772272        this->vertices=NULL;
    22782273        this->material=NULL;
    2279         this->matpar=NULL;
    22802274        this->verticalneighbors=NULL;
    22812275        this->parameters=NULL;
    … …  
    22852279        this->hvertices->reset();
    22862280        this->hmaterial->reset();
    2287         this->hmatpar->reset();
    22882281        if(this->hneighbors) this->hneighbors->reset();
    22892282
    … …  
    24612454        tria->material=(Material*)this->material->copy2(tria);
    24622455
    2463         /*recover nodes, material and matpar: */
     2456        /*recover nodes, material*/
    24642457        tria->nodes=(Node**)tria->hnodes[analysis_counter]->deliverp();
    24652458        tria->vertices=(Vertex**)tria->hvertices->deliverp();
    2466         tria->matpar=(Matpar*)tria->hmatpar->delivers();
    24672459
    24682460        /*Return new Tria*/
    … …  
    27512743
    27522744        /*Get material parameters :*/
    2753         rho_ice=matpar->GetMaterialParameter(MaterialsRhoIceEnum);
     2745        rho_ice=FindParam(MaterialsRhoIceEnum);
    27542746        Input* floatingmelt_input = this->GetInput(BasalforcingsFloatingiceMeltingRateEnum); _assert_(floatingmelt_input);
    27552747        Input* gllevelset_input = this->GetInput(MaskGroundediceLevelsetEnum); _assert_(gllevelset_input);
    … …  
    27962788
    27972789        /*Get material parameters :*/
    2798         rho_ice=matpar->GetMaterialParameter(MaterialsRhoIceEnum);
     2790        rho_ice=FindParam(MaterialsRhoIceEnum);
    27992791        Input* groundedmelt_input = this->GetInput(BasalforcingsGroundediceMeltingRateEnum); _assert_(groundedmelt_input);
    28002792        Input* gllevelset_input = this->GetInput(MaskGroundediceLevelsetEnum); _assert_(gllevelset_input);
    … …  
    28352827
    28362828        /*Get material parameters :*/
    2837         rho_ice=matpar->GetMaterialParameter(MaterialsRhoIceEnum);
     2829        rho_ice=FindParam(MaterialsRhoIceEnum);
    28382830
    28392831        if(!IsIceInElement() || !IsOnSurface()) return 0.;
    … …  
    34923484                                                /*hydrostatic equilibrium: */
    34933485                                                IssmDouble rho_ice,rho_water,di;
    3494                                                 rho_ice=this->matpar->GetMaterialParameter(MaterialsRhoIceEnum);
    3495                                                 rho_water=this->matpar->GetMaterialParameter(MaterialsRhoSeawaterEnum);
     3486                                                rho_ice=this->FindParam(MaterialsRhoIceEnum);
     3487                                                rho_water=this->FindParam(MaterialsRhoSeawaterEnum);
    34963488
    34973489                                                di=rho_ice/rho_water;

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

    r23599 r23644  
    1919class Node;
    2020class Material;
    21 class Matpar;
    2221class Tria;
    2322class ElementMatrix;

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

    r23066 r23644  
    3636                        this->vertices = NULL;
    3737                        this->material = NULL;
    38                         this->matpar   = NULL;
    3938
    4039                        /*Only allocate pointer*/
    … …  
    7877        seg->hvertices = (Hook*)this->hvertices->copy();
    7978        seg->hmaterial = (Hook*)this->hmaterial->copy();
    80         seg->hmatpar   = (Hook*)this->hmatpar->copy();
    8179        seg->hneighbors = NULL;
    8280
    … …  
    10098        seg->vertices = (Vertex**)this->hvertices->deliverp();
    10199        seg->material = (Material*)this->hmaterial->delivers();
    102         seg->matpar   = (Matpar*)this->hmatpar->delivers();
    103100
    104101        return seg;
    … …  
    117114        vertices = (Vertex**)this->hvertices->deliverp();
    118115        material = (Material*)this->hmaterial->delivers();
    119         matpar   = (Matpar*)this->hmatpar->delivers();
    120116
    121117}

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

    r22990 r23644  
    1717class Node;
    1818class Material;
    19 class Matpar;
    2019class ElementMatrix;
    2120class ElementVector;

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

    r23629 r23644  
    3737                        this->vertices = NULL;
    3838                        this->material = NULL;
    39                         this->matpar   = NULL;
    4039
    4140                        /*Only allocate pointer*/
    … …  
    7978        tetra->hvertices = (Hook*)this->hvertices->copy();
    8079        tetra->hmaterial = (Hook*)this->hmaterial->copy();
    81         tetra->hmatpar   = (Hook*)this->hmatpar->copy();
    8280        tetra->hneighbors = NULL;
    8381
    … …  
    9896        tetra->vertices = (Vertex**)this->hvertices->deliverp();
    9997        tetra->material = (Material*)this->hmaterial->delivers();
    100         tetra->matpar   = (Matpar*)this->hmatpar->delivers();
    10198
    10299        return tetra;
    … …  
    114111        vertices = (Vertex**)this->hvertices->deliverp();
    115112        material = (Material*)this->hmaterial->delivers();
    116         matpar   = (Matpar*)this->hmatpar->delivers();
    117113
    118114}
    … …  
    141137        this->hvertices->configure(verticesin);
    142138        this->hmaterial->configure(materialsin);
    143         this->hmatpar->configure(materialsin);
    144139
    145140        /*Now, go pick up the objects inside the hooks: */
    … …  
    148143        this->vertices          = (Vertex**)this->hvertices->deliverp();
    149144        this->material          = (Material*)this->hmaterial->delivers();
    150         this->matpar            = (Matpar*)this->hmatpar->delivers();
    151145
    152146        /*point parameters to real dataset: */
    … …  
    812806        this->vertices=NULL;
    813807        this->material=NULL;
    814         this->matpar=NULL;
    815808        this->parameters=NULL;
    816809
    … …  
    819812        this->hvertices->reset();
    820813        this->hmaterial->reset();
    821         this->hmatpar->reset();
    822814        if(this->hneighbors) this->hneighbors->reset();
    823815}
    … …  
    872864        tria->material=(Material*)this->material->copy2(tria);
    873865
    874         /*recover nodes, material and matpar: */
     866        /*recover nodes, material*/
    875867        tria->nodes    = (Node**)tria->hnodes[analysis_counter]->deliverp();
    876868        tria->vertices = (Vertex**)tria->hvertices->deliverp();
    877         tria->matpar   = (Matpar*)tria->hmatpar->delivers();
    878869
    879870        /*Return new Tria*/

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

    r22990 r23644  
    1717class Node;
    1818class Material;
    19 class Matpar;
    2019class ElementMatrix;
    2120class ElementVector;

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

    r23629 r23644  
    4242                this->vertices = NULL;
    4343                this->material = NULL;
    44                 this->matpar   = NULL;
    4544                if(nummodels>0){
    4645                        this->element_type_list=xNew<int>(nummodels);
    … …  
    8786        tria->hvertices = (Hook*)this->hvertices->copy();
    8887        tria->hmaterial = (Hook*)this->hmaterial->copy();
    89         tria->hmatpar   = (Hook*)this->hmatpar->copy();
    9088        tria->hneighbors = NULL;
    9189
    … …  
    109107        tria->vertices = (Vertex**)this->hvertices->deliverp();
    110108        tria->material = (Material*)this->hmaterial->delivers();
    111         tria->matpar   = (Matpar*)this->hmatpar->delivers();
    112109
    113110        return tria;
    … …  
    125122        vertices = (Vertex**)this->hvertices->deliverp();
    126123        material = (Material*)this->hmaterial->delivers();
    127         matpar   = (Matpar*)this->hmatpar->delivers();
    128124
    129125}
    … …  
    247243        IssmDouble  lambda1,lambda2,ex,ey,vx,vy,vel;
    248244        IssmDouble  sigma_vm[NUMVERTICES];
    249         IssmDouble  B,sigma_max,sigma_max_floating,sigma_max_grounded;
     245        IssmDouble  B,sigma_max,sigma_max_floating,sigma_max_grounded,n;
    250246        IssmDouble  epse_2,groundedice,bed;
    251247
    … …  
    261257        Input* smax_fl_input = inputs->GetInput(CalvingStressThresholdFloatingiceEnum); _assert_(smax_fl_input);
    262258        Input* smax_gr_input = inputs->GetInput(CalvingStressThresholdGroundediceEnum); _assert_(smax_gr_input);
    263         IssmDouble  n   = this->GetMaterialParameter(MaterialsRheologyNEnum);
     259        Input* n_input  = inputs->GetInput(MaterialsRheologyNEnum); _assert_(n_input);
    264260
    265261        /* Start looping on the number of vertices: */
    … …  
    270266                /*Get velocity components and thickness*/
    271267                B_input->GetInputValue(&B,gauss);
     268                n_input->GetInputValue(&n,gauss);
    272269                vx_input->GetInputValue(&vx,gauss);
    273270                vy_input->GetInputValue(&vy,gauss);
    … …  
    334331        IssmDouble  water_height, bed,Ho,thickness,surface;
    335332        IssmDouble  surface_crevasse[NUMVERTICES], basal_crevasse[NUMVERTICES], crevasse_depth[NUMVERTICES], H_surf, H_surfbasal;
    336         IssmDouble  B, strainparallel, straineffective;
     333        IssmDouble  B, strainparallel, straineffective,n;
    337334        IssmDouble  s_xx,s_xy,s_yy,s1,s2,stmp;
    338335        int crevasse_opening_stress;
    … …  
    344341        this->parameters->FindParam(&crevasse_opening_stress,CalvingCrevasseDepthEnum);
    345342
    346         IssmDouble rho_ice        = this->GetMaterialParameter(MaterialsRhoIceEnum);
    347         IssmDouble rho_seawater   = this->GetMaterialParameter(MaterialsRhoSeawaterEnum);
    348         IssmDouble rho_freshwater = this->GetMaterialParameter(MaterialsRhoFreshwaterEnum);
    349         IssmDouble constant_g     = this->GetMaterialParameter(ConstantsGEnum);
    350         IssmDouble rheology_n     = this->GetMaterialParameter(MaterialsRheologyNEnum);
     343        IssmDouble rho_ice        = this->FindParam(MaterialsRhoIceEnum);
     344        IssmDouble rho_seawater   = this->FindParam(MaterialsRhoSeawaterEnum);
     345        IssmDouble rho_freshwater = this->FindParam(MaterialsRhoFreshwaterEnum);
     346        IssmDouble constant_g     = this->FindParam(ConstantsGEnum);
    351347
    352348        Input*   H_input                 = inputs->GetInput(ThicknessEnum); _assert_(H_input);
    … …  
    362358        Input*   s_yy_input              = inputs->GetInput(DeviatoricStressyyEnum);     _assert_(s_yy_input);
    363359        Input*  B_input  = inputs->GetInput(MaterialsRheologyBbarEnum);   _assert_(B_input);
     360        Input*  n_input  = inputs->GetInput(MaterialsRheologyNEnum);   _assert_(n_input);
    364361
    365362        /*Loop over all elements of this partition*/
    … …  
    380377                s_yy_input->GetInputValue(&s_yy,gauss);
    381378                B_input->GetInputValue(&B,gauss);
     379                n_input->GetInputValue(&n,gauss);
    382380
    383381                vel=sqrt(vx*vx+vy*vy)+1.e-14;
    … …  
    391389
    392390                if(crevasse_opening_stress==0){         /*Otero2010: balance between the tensile deviatoric stress and ice overburden pressure*/
    393                         surface_crevasse[iv] = B * strainparallel * pow(straineffective, ((1 / rheology_n)-1)) / (rho_ice * constant_g);
    394                         basal_crevasse[iv] = (rho_ice/(rho_seawater-rho_ice)) * (B * strainparallel * pow(straineffective,((1/rheology_n)-1)) / (rho_ice*constant_g) - Ho);
     391                        surface_crevasse[iv] = B * strainparallel * pow(straineffective, ((1 / n)-1)) / (rho_ice * constant_g);
     392                        basal_crevasse[iv] = (rho_ice/(rho_seawater-rho_ice)) * (B * strainparallel * pow(straineffective,((1/n)-1)) / (rho_ice*constant_g) - Ho);
    395393                }
    396394                else if(crevasse_opening_stress==1){     /*Benn2017,Todd2018: maximum principal stress */       
    … …  
    730728        this->hvertices->configure(verticesin);
    731729        this->hmaterial->configure(materialsin);
    732         this->hmatpar->configure(materialsin);
    733730
    734731        /*Now, go pick up the objects inside the hooks: */
    … …  
    737734        this->vertices = (Vertex**)this->hvertices->deliverp();
    738735        this->material = (Material*)this->hmaterial->delivers();
    739         this->matpar   = (Matpar*)this->hmatpar->delivers();
    740736
    741737        /*point parameters to real dataset: */
    … …  
    10291025        GetInputListOnVertices(&pressure[0],PressureEnum);
    10301026        GetInputListOnVertices(&phi[0],MaskGroundediceLevelsetEnum);
    1031         IssmDouble rho_ice   = matpar->GetMaterialParameter(MaterialsRhoIceEnum);
    1032         IssmDouble rho_water = matpar->GetMaterialParameter(MaterialsRhoSeawaterEnum);
    1033         IssmDouble gravity   = matpar->GetMaterialParameter(ConstantsGEnum);
     1027        IssmDouble rho_ice   = FindParam(MaterialsRhoIceEnum);
     1028        IssmDouble rho_water = FindParam(MaterialsRhoSeawaterEnum);
     1029        IssmDouble gravity   = FindParam(ConstantsGEnum);
    10341030
    10351031        /* Get node coordinates and dof list: */
    … …  
    19651961        if(!IsIceInElement() || IsFloating())return 0;
    19661962
    1967         rho_ice=matpar->GetMaterialParameter(MaterialsRhoIceEnum);
    1968         rho_water=matpar->GetMaterialParameter(MaterialsRhoSeawaterEnum);
     1963        rho_ice=FindParam(MaterialsRhoIceEnum);
     1964        rho_water=FindParam(MaterialsRhoSeawaterEnum);
    19691965        ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    19701966
    … …  
    24192415
    24202416        /*Retrieve material parameters: */
    2421         rho_ice=matpar->GetMaterialParameter(MaterialsRhoIceEnum);
     2417        rho_ice=FindParam(MaterialsRhoIceEnum);
    24222418
    24232419        /*Retrieve values of the levelset defining the masscon: */
    … …  
    24622458
    24632459        /*Get material parameters :*/
    2464         rho_ice=matpar->GetMaterialParameter(MaterialsRhoIceEnum);
     2460        rho_ice=FindParam(MaterialsRhoIceEnum);
    24652461
    24662462        /*First off, check that this segment belongs to this element: */
    … …  
    25252521
    25262522        /*Get material parameters :*/
    2527         rho_ice=matpar->GetMaterialParameter(MaterialsRhoIceEnum);
     2523        rho_ice=FindParam(MaterialsRhoIceEnum);
    25282524
    25292525        /*First off, check that this segment belongs to this element: */
    … …  
    29142910
    29152911        /*Get variables*/
    2916         IssmDouble rhoi       = this->GetMaterialParameter(MaterialsRhoIceEnum);
    2917         IssmDouble rhow       = this->GetMaterialParameter(MaterialsRhoSeawaterEnum);
    2918         IssmDouble earth_grav = this->GetMaterialParameter(ConstantsGEnum);
     2912        IssmDouble rhoi       = this->FindParam(MaterialsRhoIceEnum);
     2913        IssmDouble rhow       = this->FindParam(MaterialsRhoSeawaterEnum);
     2914        IssmDouble earth_grav = this->FindParam(ConstantsGEnum);
    29192915        IssmDouble rho_star   = 1033.;             // kg/m^3
    29202916        IssmDouble nu         = rhoi/rhow;
    2921         IssmDouble latentheat = this->GetMaterialParameter(MaterialsLatentheatEnum);
    2922         IssmDouble c_p_ocean  = this->GetMaterialParameter(MaterialsMixedLayerCapacityEnum);
     2917        IssmDouble latentheat = this->FindParam(MaterialsLatentheatEnum);
     2918        IssmDouble c_p_ocean  = this->FindParam(MaterialsMixedLayerCapacityEnum);
    29232919        IssmDouble lambda     = latentheat/c_p_ocean;
    29242920        IssmDouble a          = -0.0572;          // K/psu
    2925         IssmDouble b          = 0.0788 + this->GetMaterialParameter(MaterialsMeltingpointEnum);  //K
     2921        IssmDouble b          = 0.0788 + this->FindParam(MaterialsMeltingpointEnum);  //K
    29262922        IssmDouble c          = 7.77e-4;
    29272923        IssmDouble alpha      = 7.5e-5;           // 1/K
    … …  
    31393135
    31403136        /*material parameters: */
    3141         rho_water=matpar->GetMaterialParameter(MaterialsRhoSeawaterEnum);
    3142         rho_ice=matpar->GetMaterialParameter(MaterialsRhoIceEnum);
     3137        rho_water=FindParam(MaterialsRhoSeawaterEnum);
     3138        rho_ice=FindParam(MaterialsRhoIceEnum);
    31433139        density=rho_ice/rho_water;
    31443140        GetInputListOnVertices(&h[0],ThicknessEnum);
    … …  
    32563252        this->vertices=NULL;
    32573253        this->material=NULL;
    3258         this->matpar=NULL;
    32593254        this->parameters=NULL;
    32603255
    … …  
    32633258        this->hvertices->reset();
    32643259        this->hmaterial->reset();
    3265         this->hmatpar->reset();
    32663260        if(this->hneighbors) this->hneighbors->reset();
    32673261
    … …  
    34133407        seg->material=(Material*)this->material->copy2(seg);
    34143408
    3415         /*recover nodes, material and matpar: */
     3409        /*recover nodes, material*/
    34163410        seg->nodes    = (Node**)seg->hnodes[analysis_counter]->deliverp();
    34173411        seg->vertices = (Vertex**)seg->hvertices->deliverp();
    3418         seg->matpar   = (Matpar*)seg->hmatpar->delivers();
    34193412
    34203413        /*Return new Seg*/
    … …  
    36183611
    36193612        /*Get material parameters :*/
    3620         rho_ice=matpar->GetMaterialParameter(MaterialsRhoIceEnum);
     3613        rho_ice=FindParam(MaterialsRhoIceEnum);
    36213614        Input* floatingmelt_input = this->GetInput(BasalforcingsFloatingiceMeltingRateEnum); _assert_(floatingmelt_input);
    36223615        Input* gllevelset_input = this->GetInput(MaskGroundediceLevelsetEnum); _assert_(gllevelset_input);
    … …  
    36633656
    36643657        /*Get material parameters :*/
    3665         rho_ice=matpar->GetMaterialParameter(MaterialsRhoIceEnum);
     3658        rho_ice=FindParam(MaterialsRhoIceEnum);
    36663659        Input* groundedmelt_input = this->GetInput(BasalforcingsGroundediceMeltingRateEnum); _assert_(groundedmelt_input);
    36673660        Input* gllevelset_input = this->GetInput(MaskGroundediceLevelsetEnum); _assert_(gllevelset_input);
    … …  
    37023695
    37033696        /*Get material parameters :*/
    3704         rho_ice=matpar->GetMaterialParameter(MaterialsRhoIceEnum);
     3697        rho_ice=FindParam(MaterialsRhoIceEnum);
    37053698
    37063699   if(!IsIceInElement())return 0;
    … …  
    40764069
    40774070        /*recover material parameters: */
    4078         lithosphere_shear_modulus=matpar->GetMaterialParameter(MaterialsLithosphereShearModulusEnum);
    4079         lithosphere_density=matpar->GetMaterialParameter(MaterialsLithosphereDensityEnum);
    4080         mantle_shear_modulus=matpar->GetMaterialParameter(MaterialsMantleShearModulusEnum);
    4081         mantle_density=matpar->GetMaterialParameter(MaterialsMantleDensityEnum);
    4082         rho_ice=matpar->GetMaterialParameter(MaterialsRhoIceEnum);
     4071        lithosphere_shear_modulus=FindParam(MaterialsLithosphereShearModulusEnum);
     4072        lithosphere_density=FindParam(MaterialsLithosphereDensityEnum);
     4073        mantle_shear_modulus=FindParam(MaterialsMantleShearModulusEnum);
     4074        mantle_density=FindParam(MaterialsMantleDensityEnum);
     4075        rho_ice=FindParam(MaterialsRhoIceEnum);
    40834076
    40844077        /*pull thickness averages: */
    … …  
    41854178
    41864179        /*recover material parameters: */
    4187         rho_ice=matpar->GetMaterialParameter(MaterialsRhoIceEnum);
    4188         rho_earth=matpar->GetMaterialParameter(MaterialsEarthDensityEnum);
     4180        rho_ice=FindParam(MaterialsRhoIceEnum);
     4181        rho_earth=FindParam(MaterialsEarthDensityEnum);
    41894182
    41904183        /*how many dofs are we working with here? */
    … …  
    43234316
    43244317        /*recover material parameters: */
    4325         rho_ice=matpar->GetMaterialParameter(MaterialsRhoIceEnum);
    4326         rho_earth=matpar->GetMaterialParameter(MaterialsEarthDensityEnum);
     4318        rho_ice=FindParam(MaterialsRhoIceEnum);
     4319        rho_earth=FindParam(MaterialsEarthDensityEnum);
    43274320
    43284321        /*how many dofs are we working with here? */
    … …  
    45284521
    45294522                /*recover material parameters: */
    4530                 rho_water=matpar->GetMaterialParameter(MaterialsRhoFreshwaterEnum);
     4523                rho_water=FindParam(MaterialsRhoFreshwaterEnum);
    45314524
    45324525                /*From Sg_old, recover water sea level rise:*/
    … …  
    45464539
    45474540                /*recover material parameters: */
    4548                 rho_ice=matpar->GetMaterialParameter(MaterialsRhoIceEnum);
     4541                rho_ice=FindParam(MaterialsRhoIceEnum);
    45494542
    45504543                /*Compute ice thickness change: */
    … …  
    46144607
    46154608        /*recover material parameters: */
    4616         rho_ice=matpar->GetMaterialParameter(MaterialsRhoIceEnum);
    4617         rho_water=matpar->GetMaterialParameter(MaterialsRhoFreshwaterEnum);
    4618         rho_earth=matpar->GetMaterialParameter(MaterialsEarthDensityEnum);
     4609        rho_ice=FindParam(MaterialsRhoIceEnum);
     4610        rho_water=FindParam(MaterialsRhoFreshwaterEnum);
     4611        rho_earth=FindParam(MaterialsEarthDensityEnum);
    46194612
    46204613        /*recover love numbers and computational flags: */
    … …  
    48084801
    48094802        /*recover material parameters: */
    4810         rho_water=matpar->GetMaterialParameter(MaterialsRhoFreshwaterEnum);
    4811         rho_earth=matpar->GetMaterialParameter(MaterialsEarthDensityEnum);
     4803        rho_water=FindParam(MaterialsRhoFreshwaterEnum);
     4804        rho_earth=FindParam(MaterialsEarthDensityEnum);
    48124805
    48134806        /*how many dofs are we working with here? */
    … …  
    49604953
    49614954        /*recover material parameters: */
    4962         rho_ice=matpar->GetMaterialParameter(MaterialsRhoIceEnum);
    4963         rho_water=matpar->GetMaterialParameter(MaterialsRhoFreshwaterEnum);
    4964         rho_earth=matpar->GetMaterialParameter(MaterialsEarthDensityEnum);
     4955        rho_ice=FindParam(MaterialsRhoIceEnum);
     4956        rho_water=FindParam(MaterialsRhoFreshwaterEnum);
     4957        rho_earth=FindParam(MaterialsEarthDensityEnum);
    49654958
    49664959        /*how many dofs are we working with here? */
    … …  
    51935186                                                /*hydrostatic equilibrium: */
    51945187                                                IssmDouble rho_ice,rho_water,di;
    5195                                                 rho_ice   = this->matpar->GetMaterialParameter(MaterialsRhoIceEnum);
    5196                                                 rho_water = this->matpar->GetMaterialParameter(MaterialsRhoSeawaterEnum);
     5188                                                rho_ice   = this->FindParam(MaterialsRhoIceEnum);
     5189                                                rho_water = this->FindParam(MaterialsRhoSeawaterEnum);
    51975190                                                di        = rho_ice/rho_water;
    51985191

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

    r23599 r23644  
    1717class Node;
    1818class Material;
    19 class Matpar;
    2019class Seg;
    2120class ElementMatrix;

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

    r23642 r23644  
    29932993                element->GetInputListOnVertices(&r[0],BedEnum);
    29942994                element->GetInputListOnVertices(&sl[0],SealevelEnum);
    2995                 rho_water   = element->matpar->GetMaterialParameter(MaterialsRhoSeawaterEnum);
    2996                 rho_ice     = element->matpar->GetMaterialParameter(MaterialsRhoIceEnum);
     2995                rho_water   = element->FindParam(MaterialsRhoSeawaterEnum);
     2996                rho_ice     = element->FindParam(MaterialsRhoIceEnum);
    29972997                density     = rho_ice/rho_water;
    29982998
    … …  
    33703370                        newtria->vertices=NULL;
    33713371                        newtria->material=NULL;
    3372                         newtria->matpar=NULL;
    33733372                        if(this->nummodels>0){
    33743373                                newtria->element_type_list=xNew<int>(this->nummodels);
    … …  
    33783377
    33793378                        /*Element hook*/
    3380                         int matpar_id=newnumberofelements+1; //retrieve material parameter id (last pointer in femodel->materials)
    33813379                        int material_id=i+1; // retrieve material_id = i+1;
    33823380                        /*retrieve vertices ids*/
    … …  
    33883386                        newtria->hvertices   =new Hook(&vertex_ids[0],elementswidth);
    33893387                        newtria->hmaterial   =new Hook(&material_id,1);
    3390                         newtria->hmatpar     =new Hook(&matpar_id,1);
    33913388                        newtria->hneighbors  =NULL;
    33923389                        /*Initialize hnodes as NULL*/
    … …  
    34083405                }
    34093406        }
    3410 
    3411         /*Add new constant material property to materials, at the end: */
    3412         Matpar *newmatpar=static_cast<Matpar*>(this->materials->GetObjectByOffset(this->materials->Size()-1)->copy());
    3413         newmatpar->SetMid(newnumberofelements+1);
    3414         materials->AddObject(newmatpar);//put it at the end of the materials
    34153407}
    34163408/*}}}*/

  • issm/trunk-jpl/src/c/classes/Loads/Friction.cpp

    r23538 r23644  
    263263        element->GetInputValue(&drag_coefficient, gauss,FrictionCoefficientEnum);
    264264        element->GetInputValue(&drag_coefficient_coulomb, gauss,FrictionCoefficientcoulombEnum);
    265         IssmDouble rho_water = element->GetMaterialParameter(MaterialsRhoSeawaterEnum);
    266         IssmDouble rho_ice   = element->GetMaterialParameter(MaterialsRhoIceEnum);
    267         IssmDouble gravity   = element->GetMaterialParameter(ConstantsGEnum);
     265        IssmDouble rho_water = element->FindParam(MaterialsRhoSeawaterEnum);
     266        IssmDouble rho_ice   = element->FindParam(MaterialsRhoIceEnum);
     267        IssmDouble gravity   = element->FindParam(ConstantsGEnum);
    268268
    269269        //compute r and q coefficients: */
    … …  
    398398        element->GetInputValue(&sealevel, gauss,SealevelEnum);
    399399        element->GetInputValue(&drag_coefficient, gauss,FrictionCoefficientEnum);
    400         IssmDouble rho_water   = element->GetMaterialParameter(MaterialsRhoFreshwaterEnum);
    401         IssmDouble rho_ice     = element->GetMaterialParameter(MaterialsRhoIceEnum);
    402         IssmDouble gravity     = element->GetMaterialParameter(ConstantsGEnum);
     400        IssmDouble rho_water   = element->FindParam(MaterialsRhoFreshwaterEnum);
     401        IssmDouble rho_ice     = element->FindParam(MaterialsRhoIceEnum);
     402        IssmDouble gravity     = element->FindParam(ConstantsGEnum);
    403403
    404404        //From base and thickness, compute effective pressure when drag is viscous:
    … …  
    564564        element->GetInputValue(&drag_coefficient, gauss,FrictionCoefficientEnum);
    565565        element->GetInputValue(&water_layer, gauss,FrictionWaterLayerEnum);
    566         IssmDouble rho_water   = element->GetMaterialParameter(MaterialsRhoSeawaterEnum);
    567         IssmDouble rho_ice     = element->GetMaterialParameter(MaterialsRhoIceEnum);
    568         IssmDouble gravity     = element->GetMaterialParameter(ConstantsGEnum);
     566        IssmDouble rho_water   = element->FindParam(MaterialsRhoSeawaterEnum);
     567        IssmDouble rho_ice     = element->FindParam(MaterialsRhoIceEnum);
     568        IssmDouble gravity     = element->FindParam(ConstantsGEnum);
    569569
    570570        //compute r and q coefficients: */
    … …  
    700700        element->GetInputValue(&base, gauss,BaseEnum);
    701701        //element->GetInputValue(&sealevel, gauss,SealevelEnum);
    702         IssmDouble rho_ice   = element->GetMaterialParameter(MaterialsRhoIceEnum);
    703         IssmDouble gravity   = element->GetMaterialParameter(ConstantsGEnum);
     702        IssmDouble rho_ice   = element->FindParam(MaterialsRhoIceEnum);
     703        IssmDouble gravity   = element->FindParam(ConstantsGEnum);
    704704        P0 = gravity*rho_ice*thickness;
    705705
    … …  
    764764                                         element->GetInputValue(&base, gauss,BaseEnum);
    765765                                         element->GetInputValue(&sealevel, gauss,SealevelEnum);
    766                                          IssmDouble rho_water = element->GetMaterialParameter(MaterialsRhoSeawaterEnum);
    767                                          IssmDouble rho_ice   = element->GetMaterialParameter(MaterialsRhoIceEnum);
    768                                          IssmDouble gravity   = element->GetMaterialParameter(ConstantsGEnum);
     766                                         IssmDouble rho_water = element->FindParam(MaterialsRhoSeawaterEnum);
     767                                         IssmDouble rho_ice   = element->FindParam(MaterialsRhoIceEnum);
     768                                         IssmDouble gravity   = element->FindParam(ConstantsGEnum);
    769769                                         p_ice   = gravity*rho_ice*thickness;
    770770                                         p_water = rho_water*gravity*(sealevel-base);
    … …  
    774774                case 1:{
    775775                                         element->GetInputValue(&thickness, gauss,ThicknessEnum);
    776                                          IssmDouble rho_ice   = element->GetMaterialParameter(MaterialsRhoIceEnum);
    777                                          IssmDouble gravity   = element->GetMaterialParameter(ConstantsGEnum);
     776                                         IssmDouble rho_ice   = element->FindParam(MaterialsRhoIceEnum);
     777                                         IssmDouble gravity   = element->FindParam(ConstantsGEnum);
    778778                                         p_ice   = gravity*rho_ice*thickness;
    779779                                         p_water = 0.;
    … …  
    785785                                         element->GetInputValue(&base, gauss,BaseEnum);
    786786                                         element->GetInputValue(&sealevel, gauss,SealevelEnum);
    787                                          IssmDouble rho_water = element->GetMaterialParameter(MaterialsRhoSeawaterEnum);
    788                                          IssmDouble rho_ice   = element->GetMaterialParameter(MaterialsRhoIceEnum);
    789                                          IssmDouble gravity   = element->GetMaterialParameter(ConstantsGEnum);
     787                                         IssmDouble rho_water = element->FindParam(MaterialsRhoSeawaterEnum);
     788                                         IssmDouble rho_ice   = element->FindParam(MaterialsRhoIceEnum);
     789                                         IssmDouble gravity   = element->FindParam(ConstantsGEnum);
    790790                                         p_ice   = gravity*rho_ice*thickness;
    791791                                         p_water = max(0.,rho_water*gravity*(sealevel-base));

  • issm/trunk-jpl/src/c/classes/Loads/Friction.h

    r23020 r23644  
    77
    88/*Headers:*/
    9 /*{{{*/
    109class Inputs;
    11 class Matpar;
    1210class GaussPenta;
    1311class GaussTria;
    14 /*}}}*/
    1512
    1613class Friction{

  • issm/trunk-jpl/src/c/classes/Loads/Moulin.cpp

    r23612 r23644  
    2626        this->helement=NULL;
    2727        this->element=NULL;
    28         this->hmatpar=NULL;
    29         this->matpar=NULL;
    3028}
    3129/*}}}*/
    … …  
    3331
    3432        int pengrid_node_id;
    35         int pengrid_matpar_id;
    3633        int pengrid_element_id;
    3734
    … …  
    4946        pengrid_element_id=iomodel->singlenodetoelementconnectivity[index];
    5047        _assert_(pengrid_element_id);
    51         pengrid_matpar_id=iomodel->numberofelements+1; //refers to the constant material parameters object
    5248
    5349        this->hnode=new Hook(&pengrid_node_id,1);
    5450        this->helement=new Hook(&pengrid_element_id,1);
    55         this->hmatpar=new Hook(&pengrid_matpar_id,1);
    5651
    5752        //this->parameters: we still can't point to it, it may not even exist. Configure will handle this.
    … …  
    5954        this->node=NULL;
    6055        this->element=NULL;
    61         this->matpar=NULL;
    6256}
    6357/*}}}*/
    … …  
    6559        delete hnode;
    6660        delete helement;
    67         delete hmatpar;
    6861        return;
    6962}
    … …  
    8679        /*now deal with hooks and objects: */
    8780        pengrid->hnode=(Hook*)this->hnode->copy();
    88         pengrid->hmatpar=(Hook*)this->hmatpar->copy();
    8981        pengrid->helement=(Hook*)this->helement->copy();
    9082
    9183        /*corresponding fields*/
    9284        pengrid->node  =(Node*)pengrid->hnode->delivers();
    93         pengrid->matpar =(Matpar*)pengrid->hmatpar->delivers();
    9485        pengrid->element=(Element*)pengrid->helement->delivers();
    9586
    … …  
    10495        hnode->DeepEcho();
    10596        helement->DeepEcho();
    106         hmatpar->DeepEcho();
    10797        _printf_("   parameters\n");
    10898        parameters->DeepEcho();
    … …  
    127117                this->hnode      = new Hook();
    128118                this->helement   = new Hook();
    129                 this->hmatpar    = new Hook();
    130119        }
    131120
    132121        this->hnode->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    133122        this->helement->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    134         this->hmatpar->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    135123
    136124        /*corresponding fields*/
    137125        node   =(Node*)this->hnode->delivers();
    138         matpar =(Matpar*)this->hmatpar->delivers();
    139126        element=(Element*)this->helement->delivers();
    140127}
    … …  
    153140        hnode->configure(nodesin);
    154141        helement->configure(elementsin);
    155         hmatpar->configure(materialsin);
    156142
    157143        /*Get corresponding fields*/
    158144        node=(Node*)hnode->delivers();
    159145        element=(Element*)helement->delivers();
    160         matpar=(Matpar*)hmatpar->delivers();
    161146
    162147        /*point parameters to real dataset: */
    … …  
    240225        this->node=NULL;
    241226        this->element=NULL;
    242         this->matpar=NULL;
    243227        this->parameters=NULL;
    244228
    … …  
    246230        this->hnode->reset();
    247231        this->helement->reset();
    248         this->hmatpar->reset();
    249232
    250233}

  • issm/trunk-jpl/src/c/classes/Loads/Moulin.h

    r23588 r23644  
    2929                Hook* hnode;  //hook to 1 node
    3030                Hook* helement;  //hook to 1 element
    31                 Hook* hmatpar; //hook to 1 matpar
    3231
    3332                /*Corresponding fields*/
    3433                Node    *node;
    3534                Element *element;
    36                 Matpar  *matpar;
    3735
    3836                Parameters* parameters; //pointer to solution parameters

  • issm/trunk-jpl/src/c/classes/Loads/Pengrid.cpp

    r23612 r23644  
    2626        this->helement=NULL;
    2727        this->element=NULL;
    28         this->hmatpar=NULL;
    29         this->matpar=NULL;
    3028
    3129        /*not active, not zigzagging: */
    … …  
    3836
    3937        int pengrid_node_id;
    40         int pengrid_matpar_id;
    4138        int pengrid_element_id;
    4239
    … …  
    5451        pengrid_element_id=iomodel->singlenodetoelementconnectivity[index];
    5552        _assert_(pengrid_element_id);
    56         pengrid_matpar_id=iomodel->numberofelements+1; //refers to the constant material parameters object
    5753
    5854        this->hnode=new Hook(&pengrid_node_id,1);
    5955        this->helement=new Hook(&pengrid_element_id,1);
    60         this->hmatpar=new Hook(&pengrid_matpar_id,1);
    6156
    6257        //this->parameters: we still can't point to it, it may not even exist. Configure will handle this.
    … …  
    6459        this->node=NULL;
    6560        this->element=NULL;
    66         this->matpar=NULL;
    6761
    6862        //let's not forget internals
    … …  
    7569        delete hnode;
    7670        delete helement;
    77         delete hmatpar;
    7871        return;
    7972}
    … …  
    9689        /*now deal with hooks and objects: */
    9790        pengrid->hnode=(Hook*)this->hnode->copy();
    98         pengrid->hmatpar=(Hook*)this->hmatpar->copy();
    9991        pengrid->helement=(Hook*)this->helement->copy();
    10092
    10193        /*corresponding fields*/
    10294        pengrid->node  =(Node*)pengrid->hnode->delivers();
    103         pengrid->matpar =(Matpar*)pengrid->hmatpar->delivers();
    10495        pengrid->element=(Element*)pengrid->helement->delivers();
    10596
    … …  
    119110        hnode->DeepEcho();
    120111        helement->DeepEcho();
    121         hmatpar->DeepEcho();
    122112        _printf_("   active " << this->active << "\n");
    123113        _printf_("   zigzag_counter " << this->zigzag_counter << "\n");
    … …  
    144134                this->hnode      = new Hook();
    145135                this->helement   = new Hook();
    146                 this->hmatpar    = new Hook();
    147136        }
    148137
    149138        this->hnode->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    150139        this->helement->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    151         this->hmatpar->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    152140
    153141        /*corresponding fields*/
    154142        node   =(Node*)this->hnode->delivers();
    155         matpar =(Matpar*)this->hmatpar->delivers();
    156143        element=(Element*)this->helement->delivers();
    157144
    … …  
    174161        hnode->configure(nodesin);
    175162        helement->configure(elementsin);
    176         hmatpar->configure(materialsin);
    177163
    178164        /*Get corresponding fields*/
    179165        node=(Node*)hnode->delivers();
    180166        element=(Element*)helement->delivers();
    181         matpar=(Matpar*)hmatpar->delivers();
    182167
    183168        /*point parameters to real dataset: */
    … …  
    285270        this->node=NULL;
    286271        this->element=NULL;
    287         this->matpar=NULL;
    288272        this->parameters=NULL;
    289273
    … …  
    291275        this->hnode->reset();
    292276        this->helement->reset();
    293         this->hmatpar->reset();
    294277
    295278}
    … …  
    464447
    465448        //Compute pressure melting point
    466         t_pmp=matpar->TMeltingPoint(pressure);
     449        t_pmp=element->TMeltingPoint(pressure);
    467450
    468451        //Figure out if temperature is over melting_point, in which case, this penalty needs to be activated.
    … …  
    532515
    533516        /*Compute pressure melting point*/
    534         t_pmp=matpar->GetMaterialParameter(MaterialsMeltingpointEnum)-matpar->GetMaterialParameter(MaterialsBetaEnum)*pressure;
     517        t_pmp=parameters->FindParam(MaterialsMeltingpointEnum)-parameters->FindParam(MaterialsBetaEnum)*pressure;
    535518
    536519        /*Add penalty load*/
    … …  
    607590
    608591        /*Compute pressure melting point*/
    609         t_pmp=matpar->GetMaterialParameter(MaterialsMeltingpointEnum)-matpar->GetMaterialParameter(MaterialsBetaEnum)*pressure;
     592        t_pmp=parameters->FindParam(MaterialsMeltingpointEnum)-parameters->FindParam(MaterialsBetaEnum)*pressure;
    610593
    611594        /*Add penalty load
    … …  
    642625
    643626        /*Compute pressure melting point*/
    644         t_pmp=matpar->GetMaterialParameter(MaterialsMeltingpointEnum)-matpar->GetMaterialParameter(MaterialsBetaEnum)*pressure;
     627        t_pmp=parameters->FindParam(MaterialsMeltingpointEnum)-parameters->FindParam(MaterialsBetaEnum)*pressure;
    645628
    646629        pe->values[0]=kmax*pow(10.,penalty_factor)*t_pmp;

  • issm/trunk-jpl/src/c/classes/Loads/Pengrid.h

    r23588 r23644  
    2929                Hook* hnode;  //hook to 1 node
    3030                Hook* helement;  //hook to 1 element
    31                 Hook* hmatpar; //hook to 1 matpar
    3231
    3332                /*Corresponding fields*/
    3433                Node    *node;
    3534                Element *element;
    36                 Matpar  *matpar;
    3735
    3836                Parameters* parameters; //pointer to solution parameters

  • issm/trunk-jpl/src/c/classes/Loads/Riftfront.cpp

    r23612 r23644  
    2424        this->hnodes=NULL;
    2525        this->helements=NULL;
    26         this->hmatpar=NULL;
    2726        this->nodes=NULL;
    2827        this->elements=NULL;
    29         this->matpar=NULL;
    3028}
    3129/*}}}*/
    … …  
    3634        int    riftfront_node_ids[2];
    3735        int    riftfront_elem_ids[2];
    38         int    riftfront_matpar_id;
    3936        IssmDouble riftfront_friction;
    4037        IssmDouble riftfront_fractionincrement;
    … …  
    6461        riftfront_elem_ids[0]=el1;
    6562        riftfront_elem_ids[1]=el2;
    66         riftfront_matpar_id=iomodel->numberofelements+1; //matlab indexing
    6763
    6864        /*Hooks: */
    6965        this->hnodes=new Hook(riftfront_node_ids,2);
    7066        this->helements=new Hook(riftfront_elem_ids,2);
    71         this->hmatpar=new Hook(&riftfront_matpar_id,1);
    7267
    7368        /*computational parameters: */
    … …  
    9590        this->nodes= NULL;
    9691        this->elements= NULL;
    97         this->matpar= NULL;
    9892
    9993}
    … …  
    10397        delete hnodes;
    10498        delete helements;
    105         delete hmatpar;
    10699}
    107100/*}}}*/
    … …  
    129122        riftfront->hnodes=(Hook*)this->hnodes->copy();
    130123        riftfront->helements=(Hook*)this->helements->copy();
    131         riftfront->hmatpar=(Hook*)this->hmatpar->copy();
    132124
    133125        /*corresponding fields*/
    134126        riftfront->nodes   =(Node**)riftfront->hnodes->deliverp();
    135127        riftfront->elements=(Element**)riftfront->helements->deliverp();
    136         riftfront->matpar  =(Matpar*)riftfront->hmatpar->delivers();
    137128
    138129        /*internal data: */
    … …  
    160151        hnodes->DeepEcho();
    161152        helements->DeepEcho();
    162         hmatpar->DeepEcho();
    163153        _printf_("   parameters\n");
    164154        if(parameters)parameters->DeepEcho();
    … …  
    172162        _printf_("   hnodes: " << hnodes << "\n");
    173163        _printf_("   helements: " << helements << "\n");
    174         _printf_("   hmatpar: " << hmatpar << "\n");
    175164        _printf_("   parameters: " << parameters << "\n");
    176165        _printf_("   internal parameters: \n");
    … …  
    209198        if(marshall_direction==MARSHALLING_BACKWARD){
    210199                this->hnodes      = new Hook();
    211                 this->hmatpar     = new Hook();
    212200                this->helements   = new Hook();
    213201        }
    214202
    215203        this->hnodes->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    216         this->hmatpar->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    217204        this->helements->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    218205
    219206        /*corresponding fields*/
    220207        nodes     =(Node**)this->hnodes->deliverp();
    221         matpar    =(Matpar*)this->hmatpar->delivers();
    222208        elements  =(Element**)this->helements->deliverp();
    223209
    … …  
    265251        hnodes->configure(nodesin);
    266252        helements->configure(elementsin);
    267         hmatpar->configure(materialsin);
    268253
    269254        /*Initialize hooked fields*/
    270255        this->nodes   =(Node**)hnodes->deliverp();
    271256        this->elements=(Element**)helements->deliverp();
    272         this->matpar  =(Matpar*)hmatpar->delivers();
    273257
    274258        /*point parameters to real dataset: */
    … …  
    366350        this->nodes=NULL;
    367351        this->elements=NULL;
    368         this->matpar=NULL;
    369352        this->parameters=NULL;
    370353
    … …  
    372355        this->hnodes->reset();
    373356        this->helements->reset();
    374         this->hmatpar->reset();
    375357
    376358}
    … …  
    543525
    544526        /*Get some inputs: */
    545         rho_ice=matpar->GetMaterialParameter(MaterialsRhoIceEnum);
    546         rho_water=matpar->GetMaterialParameter(MaterialsRhoSeawaterEnum);
    547         gravity=matpar->GetMaterialParameter(ConstantsGEnum);
     527        rho_ice=tria1->FindParam(MaterialsRhoIceEnum);
     528        rho_water=tria1->FindParam(MaterialsRhoSeawaterEnum);
     529        gravity=tria1->FindParam(ConstantsGEnum);
    548530        tria1->GetInputValue(&h[0],nodes[0],ThicknessEnum);
    549531        tria2->GetInputValue(&h[1],nodes[1],ThicknessEnum);

  • issm/trunk-jpl/src/c/classes/Loads/Riftfront.h

    r23588 r23644  
    3030                Hook* hnodes;
    3131                Hook* helements;
    32                 Hook* hmatpar;
    3332
    3433                /*Corresponding fields*/
    35                 Matpar   *matpar;
    3634                Node    **nodes;
    3735                Element **elements;

  • issm/trunk-jpl/src/c/classes/Materials/Matice.cpp

    r23524 r23644  
    768768        surface_input->GetInputDerivativeValue(&slope[0],xyz_list,gauss);
    769769        z=this->element->GetZcoord(xyz_list,gauss);
    770         tau_perp = element->matpar->GetMaterialParameter(MaterialsRhoIceEnum) * element->matpar->GetMaterialParameter(ConstantsGEnum) * fabs(s-z)*sqrt(slope[0]*slope[0]+slope[1]*slope[1]);
     770        tau_perp = element->FindParam(MaterialsRhoIceEnum) * element->FindParam(ConstantsGEnum) * fabs(s-z)*sqrt(slope[0]*slope[0]+slope[1]*slope[1]);
    771771
    772772        /* Get eps_b*/

  • issm/trunk-jpl/src/c/classes/Materials/Matlitho.h

    r23524 r23644  
    7474
    7575                /*}}}*/
    76                 /*Numerics: {{{*/
    77                 void       EnthalpyToThermal(IssmDouble* ptemperature,IssmDouble* pwaterfraction,IssmDouble enthalpy,IssmDouble pressure){_error_("not supported");};
    78                 IssmDouble GetEnthalpyDiffusionParameter(IssmDouble enthalpy,IssmDouble pressure){_error_("not supported");};
    79                 IssmDouble GetEnthalpyDiffusionParameterVolume(int numvertices,IssmDouble* enthalpy,IssmDouble* pressure){_error_("not supported");};
    80                 IssmDouble GetMaterialParameter(int in_enum){_error_("not supported");};
    81                 IssmDouble PureIceEnthalpy(IssmDouble pressure){_error_("not supported");};
    82                 void       ThermalToEnthalpy(IssmDouble* penthalpy,IssmDouble temperature,IssmDouble waterfraction,IssmDouble pressure){_error_("not supported");};
    83                 IssmDouble TMeltingPoint(IssmDouble pressure){_error_("not supported");};
    84                 /*}}}*/
    8576
    8677};

  • issm/trunk-jpl/src/c/classes/Params/Parameters.cpp

    r23370 r23644  
    485485}
    486486/*}}}*/
     487IssmDouble Parameters::FindParam(int param_enum){ _assert_(this);/*{{{*/
     488        #ifdef _ISSM_DEBUG_
     489        if(param_enum<ParametersSTARTEnum || param_enum>ParametersENDEnum){
     490                _error_(EnumToStringx(param_enum) <<" is not with the parameter Enums");
     491        }
     492        #endif
     493        _assert_(param_enum>ParametersSTARTEnum);
     494        _assert_(param_enum<ParametersENDEnum);
     495
     496        int index = param_enum - ParametersSTARTEnum -1;
     497        if(!this->params[index]) _error_("Parameter " << EnumToStringx(param_enum) <<" not set");
     498
     499        IssmDouble value;
     500        this->params[index]->GetParameterValue(&value);
     501        return value;
     502}
     503/*}}}*/
    487504
    488505void   Parameters::SetParam(bool boolean,int enum_type){/*{{{*/

  • issm/trunk-jpl/src/c/classes/Params/Parameters.h

    r23310 r23644  
    5555                void  FindParamAndMakePassive(IssmPDouble** pvec,int* pM,int enum_type);
    5656                void  FindParamInDataset(IssmDouble** pIssmDoublearray,int* pM,int* pN,int dataset_type,int enum_type);
     57                IssmDouble FindParam(int enum_type);
    5758
    5859                void  SetParam(bool boolean,int enum_type);

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

    r23612 r23644  
    9090#include "./Materials/Matlitho.h"
    9191#include "./Materials/Matestar.h"
    92 #include "./Materials/Matpar.h"
    9392
    9493/*Params: */

  • issm/trunk-jpl/src/c/datastructures/DataSet.cpp

    r23551 r23644  
    173173                                this->AddObject(matestar);
    174174                        }
    175                         else if(obj_enum==MatparEnum){
    176                                 Matpar* matpar=NULL;
    177                                 matpar=new Matpar();
    178                                 matpar->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    179                                 this->AddObject(matpar);
    180                         }
    181175                        else if(obj_enum==SpcStaticEnum){
    182176                                SpcStatic* spcstatic=NULL;

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

    r23066 r23644  
    7272
    7373                                                /*Recover rho_ice: */
    74                                                 rho_ice=element->matpar->GetMaterialParameter(MaterialsRhoIceEnum);
     74                                                rho_ice=element->FindParam(MaterialsRhoIceEnum);
    7575
    7676                                                /*Recover area of element: */

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

    r23524 r23644  
    88
    99void InputUpdateFromConstantx(FemModel* femmodel,bool constant, int name){
    10 
    11         int i;
    1210        if(VerboseModule()) _printf0_("   Input updates from constant\n");
    1311
    1412        /*Elements and loads drive the update: */
    15         for(i=0;i<femmodel->elements->Size();i++){
     13        for(int i=0;i<femmodel->elements->Size();i++){
    1614                Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    1715                element->InputUpdateFromConstant(constant,name);
    18         }
    19 
    20         for(i=0;i<femmodel->materials->Size();i++){
    21                 Material* material=(Material*)femmodel->materials->GetObjectByOffset(i);
    22                 if(material->ObjectEnum()==MatparEnum){
    23                         ((Matpar*)material)->InputUpdateFromConstant(constant,name);
    24                 }
    2516        }
    2617}
    2718void InputUpdateFromConstantx(FemModel* femmodel,int constant, int name){
    2819
    29         int i;
    3020        if(VerboseModule()) _printf0_("   Input updates from constant\n");
    3121
    3222        /*Elements and loads drive the update: */
    33         for(i=0;i<femmodel->elements->Size();i++){
     23        for(int i=0;i<femmodel->elements->Size();i++){
    3424                Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    3525                element->InputUpdateFromConstant(constant,name);
    36         }
    37         for(i=0;i<femmodel->materials->Size();i++){
    38                 Material* material=(Material*)femmodel->materials->GetObjectByOffset(i);
    39                 if(material->ObjectEnum()==MatparEnum){
    40                         ((Matpar*)material)->InputUpdateFromConstant(constant,name);
    41                 }
    4226        }
    4327}
    4428void InputUpdateFromConstantx(FemModel* femmodel,IssmDouble constant, int name){
    4529
    46         int i;
    4730        if(VerboseModule()) _printf0_("   Input updates from constant\n");
    4831
    4932        /*Elements and loads drive the update: */
    50         for(i=0;i<femmodel->elements->Size();i++){
     33        for(int i=0;i<femmodel->elements->Size();i++){
    5134                Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    5235                element->InputUpdateFromConstant(constant,name);
    5336        }
    54         for(i=0;i<femmodel->materials->Size();i++){
    55                 Material* material=(Material*)femmodel->materials->GetObjectByOffset(i);
    56                 if(material->ObjectEnum()==MatparEnum){
    57                         ((Matpar*)material)->InputUpdateFromConstant(constant,name);
    58                 }
    59         }
    60 
    6137}
    6238void InputUpdateFromConstantx(Elements* elements,IssmDouble constant, int name){

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

    r23640 r23644  
    254254        /*Free data: */
    255255        iomodel->DeleteData(3,"md.material.rheology_B","md.material.rheology_n","md.damage.D");
    256 
    257         /*Add new constant material property to materials, at the end: */
    258         materials->AddObject(new Matpar(iomodel));//put it at the end of the materials
    259 
    260 
    261256}/*}}}*/
    262257void CreateVertices(Elements* elements,Vertices* vertices,IoModel* iomodel,int solution_type,bool isamr){/*{{{*/

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

    r23601 r23644  
    1919
    2020        int         i,j,m,k;
    21         int         numoutputs,materialtype,smb_model,basalforcing_model,timestepping_type;
     21        int         numoutputs,basalforcing_model,timestepping_type;
    2222        char**      requestedoutputs = NULL;
    2323        char*       fieldname = NULL;
    … …  
    272272        iomodel->DeleteData(&requestedoutputs,numoutputs,"md.steadystate.requested_outputs");
    273273
    274         iomodel->FindConstant(&materialtype,"md.materials.type");
    275         if(materialtype==MatdamageiceEnum || materialtype==MaticeEnum || materialtype==MatenhancediceEnum){
    276                 parameters->AddObject(iomodel->CopyConstantObject("md.materials.rho_ice",MaterialsRhoIceEnum));
    277         }
    278         if(materialtype==MatdamageiceEnum){
     274        int materialstype;
     275        iomodel->FindConstant(&materialstype,"md.materials.type");
     276        switch(materialstype){
     277                case MaticeEnum:
     278                case MatdamageiceEnum:
     279                case MatenhancediceEnum:
     280                case MatestarEnum:
     281                        parameters->AddObject(iomodel->CopyConstantObject("md.materials.rho_ice",MaterialsRhoIceEnum));
     282                        parameters->AddObject(iomodel->CopyConstantObject("md.materials.rho_water",MaterialsRhoSeawaterEnum));
     283                        parameters->AddObject(iomodel->CopyConstantObject("md.materials.rho_freshwater",MaterialsRhoFreshwaterEnum));
     284                        parameters->AddObject(iomodel->CopyConstantObject("md.materials.mu_water",MaterialsMuWaterEnum));
     285                        parameters->AddObject(iomodel->CopyConstantObject("md.materials.heatcapacity",MaterialsHeatcapacityEnum));
     286                        parameters->AddObject(iomodel->CopyConstantObject("md.materials.thermalconductivity",MaterialsThermalconductivityEnum));
     287                        parameters->AddObject(iomodel->CopyConstantObject("md.materials.temperateiceconductivity",MaterialsTemperateiceconductivityEnum));
     288                        parameters->AddObject(iomodel->CopyConstantObject("md.materials.latentheat",MaterialsLatentheatEnum));
     289                        parameters->AddObject(iomodel->CopyConstantObject("md.materials.beta",MaterialsBetaEnum));
     290                        parameters->AddObject(iomodel->CopyConstantObject("md.materials.meltingpoint",MaterialsMeltingpointEnum));
     291                        parameters->AddObject(iomodel->CopyConstantObject("md.constants.referencetemperature",ConstantsReferencetemperatureEnum));
     292                        parameters->AddObject(iomodel->CopyConstantObject("md.materials.mixed_layer_capacity",MaterialsMixedLayerCapacityEnum));
     293                        parameters->AddObject(iomodel->CopyConstantObject("md.materials.thermal_exchange_velocity",MaterialsThermalExchangeVelocityEnum));
     294                        parameters->AddObject(iomodel->CopyConstantObject("md.constants.g",ConstantsGEnum));
     295                        parameters->AddObject(iomodel->CopyConstantObject("md.materials.rheology_law",MaterialsRheologyLawEnum));
     296
     297                        /*gia: */
     298                        parameters->AddObject(iomodel->CopyConstantObject("md.materials.lithosphere_shear_modulus",MaterialsLithosphereShearModulusEnum));
     299                        parameters->AddObject(iomodel->CopyConstantObject("md.materials.lithosphere_density",MaterialsLithosphereDensityEnum));
     300                        parameters->AddObject(iomodel->CopyConstantObject("md.materials.mantle_shear_modulus",MaterialsMantleShearModulusEnum));
     301                        parameters->AddObject(iomodel->CopyConstantObject("md.materials.mantle_density",MaterialsMantleDensityEnum));
     302
     303                        /*slr:*/
     304                        parameters->AddObject(iomodel->CopyConstantObject("md.materials.earth_density",MaterialsEarthDensityEnum));
     305                        break;
     306                default:
     307                        _error_("Material "<< EnumToStringx(materialstype) <<" not supported yet");
     308        }
     309
     310        int smb_model;
     311        iomodel->FindConstant(&smb_model,"md.smb.model");
     312        switch(smb_model){
     313                case SMBforcingEnum:
     314                case SMBgradientsEnum:
     315                case SMBgradientselaEnum:
     316                case SMBhenningEnum:
     317                case SMBcomponentsEnum:
     318                case SMBmeltcomponentsEnum:
     319                case SMBgradientscomponentsEnum:
     320                        /*Nothing to add*/
     321                        break;
     322                case SMBgembEnum:
     323                        parameters->AddObject(iomodel->CopyConstantObject("md.smb.aIce",SmbAIceEnum));
     324                        parameters->AddObject(iomodel->CopyConstantObject("md.smb.aSnow",SmbASnowEnum));
     325                        break;
     326                case SMBpddEnum:
     327                        parameters->AddObject(iomodel->CopyConstantObject("md.smb.desfac",SmbDesfacEnum));
     328                        parameters->AddObject(iomodel->CopyConstantObject("md.smb.rlaps",SmbRlapsEnum));
     329                        parameters->AddObject(iomodel->CopyConstantObject("md.smb.rlapslgm",SmbRlapslgmEnum));
     330                        break;
     331                case SMBpddSicopolisEnum:
     332                        parameters->AddObject(iomodel->CopyConstantObject("md.smb.desfac",SmbDesfacEnum));
     333                        parameters->AddObject(iomodel->CopyConstantObject("md.smb.rlaps",SmbRlapsEnum));
     334                        break;
     335                case SMBd18opddEnum:
     336                        parameters->AddObject(iomodel->CopyConstantObject("md.smb.desfac",SmbDesfacEnum));
     337                        parameters->AddObject(iomodel->CopyConstantObject("md.smb.rlaps",SmbRlapsEnum));
     338                        parameters->AddObject(iomodel->CopyConstantObject("md.smb.rlapslgm",SmbRlapslgmEnum));
     339                        parameters->AddObject(iomodel->CopyConstantObject("md.smb.dpermil",SmbDpermilEnum));
     340                        break;
     341                case SMBsemicEnum:
     342                        parameters->AddObject(iomodel->CopyConstantObject("md.smb.desfac",SmbDesfacEnum));
     343                        parameters->AddObject(iomodel->CopyConstantObject("md.smb.rlaps",SmbRlapsEnum));
     344                        parameters->AddObject(iomodel->CopyConstantObject("md.smb.rdl",SmbRdlEnum));
     345                        break;
     346                default:
     347                        _error_("Surface mass balance model "<<EnumToStringx(smb_model)<<" not supported yet");
     348        }
     349
     350        int hydrology_model;
     351        iomodel->FindConstant(&hydrology_model,"md.hydrology.model");
     352        if(hydrology_model==HydrologydcEnum){
     353                parameters->AddObject(iomodel->CopyConstantObject("md.hydrology.sediment_compressibility",HydrologydcSedimentCompressibilityEnum));
     354                parameters->AddObject(iomodel->CopyConstantObject("md.hydrology.sediment_porosity",HydrologydcSedimentPorosityEnum));
     355                parameters->AddObject(iomodel->CopyConstantObject("md.hydrology.sediment_thickness",HydrologydcSedimentThicknessEnum));
     356                parameters->AddObject(iomodel->CopyConstantObject("md.hydrology.water_compressibility",HydrologydcWaterCompressibilityEnum));
     357                parameters->AddObject(iomodel->CopyConstantObject("md.hydrology.isefficientlayer",HydrologydcIsefficientlayerEnum));
     358
     359                bool isefficientlayer;
     360                iomodel->FindConstant(&isefficientlayer,"md.hydrology.isefficientlayer");
     361                if(isefficientlayer){
     362                        parameters->AddObject(iomodel->CopyConstantObject("md.hydrology.epl_compressibility",HydrologydcEplCompressibilityEnum));
     363                        parameters->AddObject(iomodel->CopyConstantObject("md.hydrology.epl_porosity",HydrologydcEplPorosityEnum));
     364                        parameters->AddObject(iomodel->CopyConstantObject("md.hydrology.epl_initial_thickness",HydrologydcEplInitialThicknessEnum));
     365                        parameters->AddObject(iomodel->CopyConstantObject("md.hydrology.epl_colapse_thickness",HydrologydcEplColapseThicknessEnum));
     366                        parameters->AddObject(iomodel->CopyConstantObject("md.hydrology.epl_max_thickness",HydrologydcEplMaxThicknessEnum));
     367                        parameters->AddObject(iomodel->CopyConstantObject("md.hydrology.epl_conductivity",HydrologydcEplConductivityEnum));
     368                }
     369        }
     370        else if(hydrology_model==HydrologyshreveEnum){
     371                /*Nothing to add*/
     372        }
     373        else if(hydrology_model==HydrologyshaktiEnum){
     374                /*Nothing to add*/
     375        }
     376        else if(hydrology_model==HydrologypismEnum){
     377                /*Nothing to add*/
     378        }
     379        else{
     380                _error_("Hydrology model "<<EnumToStringx(hydrology_model)<<" not supported yet");
     381        }
     382
     383        if(materialstype==MatdamageiceEnum){
    279384                iomodel->FindConstant(&requestedoutputs,&numoutputs,"md.damage.requested_outputs");
    280385                parameters->AddObject(new IntParam(DamageEvolutionNumRequestedOutputsEnum,numoutputs));

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

    r23540 r23644  
    4141
    4242                /*Get material parameters :*/
    43                 rho_ice=element->matpar->GetMaterialParameter(MaterialsRhoIceEnum);
    44                 rho_water=element->matpar->GetMaterialParameter(MaterialsRhoFreshwaterEnum);
     43                rho_ice=element->FindParam(MaterialsRhoIceEnum);
     44                rho_water=element->FindParam(MaterialsRhoFreshwaterEnum);
    4545
    4646                /* Get constants */

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

    r23637 r23644  
    7171        }
    7272
    73         if(VerboseModule()) _printf0_("   Generating matrices\n");
     73        if(VerboseModule()) _printf0_("   Assembling matrices\n");
    7474
    7575        /*Fill stiffness matrix and load vector from elements*/

  • issm/trunk-jpl/src/c/shared/Elements/elements.h

    r23508 r23644  
    4444IssmDouble StressIntensityIntegralWeight(IssmDouble depth, IssmDouble water_depth, IssmDouble thickness);
    4545
     46/*Enthalphy*/
     47void EnthalpyToThermal(IssmDouble* ptemperature,IssmDouble* pwaterfraction,IssmDouble enthalpy,IssmDouble pressure);
     48
    4649/*Print arrays*/
    4750void printarray(IssmPDouble* array,int lines,int cols=1);

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

    r23540 r23644  
    9393        CalvingMinthicknessEnum,
    9494        ConfigurationTypeEnum,
     95        ConstantsGEnum,
     96        ConstantsReferencetemperatureEnum,
    9597        ConstantsYtsEnum,
    9698        DamageC1Enum,
    … …  
    138140        HydrologydcEplflipLockEnum,
    139141        HydrologydcEplThickCompEnum,
     142        HydrologydcEplColapseThicknessEnum,
     143        HydrologydcEplCompressibilityEnum,
     144        HydrologydcEplConductivityEnum,
     145        HydrologydcEplInitialThicknessEnum,
     146        HydrologydcEplMaxThicknessEnum,
     147        HydrologydcEplPorosityEnum,
    140148        HydrologydcIsefficientlayerEnum,
    141149        HydrologydcLeakageFactorEnum,
     150        HydrologydcSedimentCompressibilityEnum,
     151        HydrologydcSedimentPorosityEnum,
     152        HydrologydcSedimentThicknessEnum,
    142153        HydrologydcMaxIterEnum,
    143154        HydrologydcPenaltyFactorEnum,
     155        HydrologydcWaterCompressibilityEnum,
    144156        HydrologydcPenaltyLockEnum,
    145157        HydrologydcRelTolEnum,
    … …  
    208220        MasstransportRequestedOutputsEnum,
    209221        MasstransportStabilizationEnum,
     222        MaterialsBetaEnum,
     223        MaterialsEarthDensityEnum,
     224        MaterialsHeatcapacityEnum,
     225        MaterialsLatentheatEnum,
     226        MaterialsLithosphereDensityEnum,
     227        MaterialsLithosphereShearModulusEnum,
     228        MaterialsMantleDensityEnum,
     229        MaterialsMantleShearModulusEnum,
     230        MaterialsMeltingpointEnum,
     231        MaterialsMixedLayerCapacityEnum,
     232        MaterialsMuWaterEnum,
     233        MaterialsRheologyLawEnum,
    210234        MaterialsRhoIceEnum,
     235        MaterialsRhoFreshwaterEnum,
     236        MaterialsRhoSeawaterEnum,
     237        MaterialsTemperateiceconductivityEnum,
     238        MaterialsThermalconductivityEnum,
     239        MaterialsThermalExchangeVelocityEnum,
    211240        MeltingOffsetEnum,
    212241        MeshAverageVertexConnectivityEnum,
    … …  
    280309        SmbAIceEnum,
    281310        SmbAIdxEnum,
     311        SmbDesfacEnum,
     312        SmbDpermilEnum,
    282313        SmbDsnowIdxEnum,
    283314        SmbASnowEnum,
    … …  
    309340        SmbPfacEnum,
    310341        SmbRequestedOutputsEnum,
     342        SmbRdlEnum,
     343        SmbRlapsEnum,
     344        SmbRlapslgmEnum,
    311345        SmbRunoffaltiEnum,
    312346        SmbRunoffgradEnum,
    … …  
    727761        ClosedEnum,
    728762        ColinearEnum,
    729         ConstantsGEnum,
    730         ConstantsReferencetemperatureEnum,
    731763        ConstraintsEnum,
    732764        ContactEnum,
    … …  
    822854        HydrologyDCEfficientAnalysisEnum,
    823855        HydrologydcEnum,
    824         HydrologydcEplColapseThicknessEnum,
    825         HydrologydcEplCompressibilityEnum,
    826         HydrologydcEplConductivityEnum,
    827         HydrologydcEplInitialThicknessEnum,
    828         HydrologydcEplMaxThicknessEnum,
    829         HydrologydcEplPorosityEnum,
    830856        HydrologydcEplThicknessStackedEnum,
    831857        HydrologydcEplThicknessEnum,
    832858        HydrologyDCInefficientAnalysisEnum,
    833         HydrologydcSedimentCompressibilityEnum,
    834         HydrologydcSedimentPorosityEnum,
    835         HydrologydcSedimentThicknessEnum,
    836         HydrologydcWaterCompressibilityEnum,
    837859        HydrologyShreveAnalysisEnum,
    838860        HydrologyshreveEnum,
    … …  
    893915        MatdamageiceEnum,
    894916        MatenhancediceEnum,
    895         MaterialsBetaEnum,
    896         MaterialsEarthDensityEnum,
     917        MatestarEnum,
    897918        MaterialsEnum,
    898         MaterialsHeatcapacityEnum,
    899         MaterialsLatentheatEnum,
    900         MaterialsLithosphereDensityEnum,
    901         MaterialsLithosphereShearModulusEnum,
    902         MaterialsMantleDensityEnum,
    903         MaterialsMantleShearModulusEnum,
    904         MaterialsMeltingpointEnum,
    905         MaterialsMixedLayerCapacityEnum,
    906         MaterialsMuWaterEnum,
    907         MaterialsRheologyLawEnum,
    908         MaterialsRhoFreshwaterEnum,
    909         MaterialsRhoSeawaterEnum,
    910         MaterialsTemperateiceconductivityEnum,
    911         MaterialsThermalconductivityEnum,
    912         MaterialsThermalExchangeVelocityEnum,
    913         MatestarEnum,
    914919        MaticeEnum,
    915920        MatlithoEnum,
    916         MatparEnum,
    917921        MatrixParamEnum,
    918922        MaxAbsVxEnum,
    … …  
    11061110        SMBcomponentsEnum,
    11071111        SMBd18opddEnum,
    1108         SmbDesfacEnum,
    1109         SmbDpermilEnum,
    11101112        SmbDzAddEnum,
    11111113        SmbFACEnum,
    … …  
    11211123        SMBpddSicopolisEnum,
    11221124        SMBgradientscomponentsEnum,
    1123         SmbRdlEnum,
    1124         SmbRlapsEnum,
    1125         SmbRlapslgmEnum,
    11261125        SmbSolutionEnum,
    11271126        SmoothAnalysisEnum,

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

    r23540 r23644  
    101101                case CalvingMinthicknessEnum : return "CalvingMinthickness";
    102102                case ConfigurationTypeEnum : return "ConfigurationType";
     103                case ConstantsGEnum : return "ConstantsG";
     104                case ConstantsReferencetemperatureEnum : return "ConstantsReferencetemperature";
    103105                case ConstantsYtsEnum : return "ConstantsYts";
    104106                case DamageC1Enum : return "DamageC1";
    … …  
    146148                case HydrologydcEplflipLockEnum : return "HydrologydcEplflipLock";
    147149                case HydrologydcEplThickCompEnum : return "HydrologydcEplThickComp";
     150                case HydrologydcEplColapseThicknessEnum : return "HydrologydcEplColapseThickness";
     151                case HydrologydcEplCompressibilityEnum : return "HydrologydcEplCompressibility";
     152                case HydrologydcEplConductivityEnum : return "HydrologydcEplConductivity";
     153                case HydrologydcEplInitialThicknessEnum : return "HydrologydcEplInitialThickness";
     154                case HydrologydcEplMaxThicknessEnum : return "HydrologydcEplMaxThickness";
     155                case HydrologydcEplPorosityEnum : return "HydrologydcEplPorosity";
    148156                case HydrologydcIsefficientlayerEnum : return "HydrologydcIsefficientlayer";
    149157                case HydrologydcLeakageFactorEnum : return "HydrologydcLeakageFactor";
     158                case HydrologydcSedimentCompressibilityEnum : return "HydrologydcSedimentCompressibility";
     159                case HydrologydcSedimentPorosityEnum : return "HydrologydcSedimentPorosity";
     160                case HydrologydcSedimentThicknessEnum : return "HydrologydcSedimentThickness";
    150161                case HydrologydcMaxIterEnum : return "HydrologydcMaxIter";
    151162                case HydrologydcPenaltyFactorEnum : return "HydrologydcPenaltyFactor";
     163                case HydrologydcWaterCompressibilityEnum : return "HydrologydcWaterCompressibility";
    152164                case HydrologydcPenaltyLockEnum : return "HydrologydcPenaltyLock";
    153165                case HydrologydcRelTolEnum : return "HydrologydcRelTol";
    … …  
    216228                case MasstransportRequestedOutputsEnum : return "MasstransportRequestedOutputs";
    217229                case MasstransportStabilizationEnum : return "MasstransportStabilization";
     230                case MaterialsBetaEnum : return "MaterialsBeta";
     231                case MaterialsEarthDensityEnum : return "MaterialsEarthDensity";
     232                case MaterialsHeatcapacityEnum : return "MaterialsHeatcapacity";
     233                case MaterialsLatentheatEnum : return "MaterialsLatentheat";
     234                case MaterialsLithosphereDensityEnum : return "MaterialsLithosphereDensity";
     235                case MaterialsLithosphereShearModulusEnum : return "MaterialsLithosphereShearModulus";
     236                case MaterialsMantleDensityEnum : return "MaterialsMantleDensity";
     237                case MaterialsMantleShearModulusEnum : return "MaterialsMantleShearModulus";
     238                case MaterialsMeltingpointEnum : return "MaterialsMeltingpoint";
     239                case MaterialsMixedLayerCapacityEnum : return "MaterialsMixedLayerCapacity";
     240                case MaterialsMuWaterEnum : return "MaterialsMuWater";
     241                case MaterialsRheologyLawEnum : return "MaterialsRheologyLaw";
    218242                case MaterialsRhoIceEnum : return "MaterialsRhoIce";
     243                case MaterialsRhoFreshwaterEnum : return "MaterialsRhoFreshwater";
     244                case MaterialsRhoSeawaterEnum : return "MaterialsRhoSeawater";
     245                case MaterialsTemperateiceconductivityEnum : return "MaterialsTemperateiceconductivity";
     246                case MaterialsThermalconductivityEnum : return "MaterialsThermalconductivity";
     247                case MaterialsThermalExchangeVelocityEnum : return "MaterialsThermalExchangeVelocity";
    219248                case MeltingOffsetEnum : return "MeltingOffset";
    220249                case MeshAverageVertexConnectivityEnum : return "MeshAverageVertexConnectivity";
    … …  
    288317                case SmbAIceEnum : return "SmbAIce";
    289318                case SmbAIdxEnum : return "SmbAIdx";
     319                case SmbDesfacEnum : return "SmbDesfac";
     320                case SmbDpermilEnum : return "SmbDpermil";
    290321                case SmbDsnowIdxEnum : return "SmbDsnowIdx";
    291322                case SmbASnowEnum : return "SmbASnow";
    … …  
    317348                case SmbPfacEnum : return "SmbPfac";
    318349                case SmbRequestedOutputsEnum : return "SmbRequestedOutputs";
     350                case SmbRdlEnum : return "SmbRdl";
     351                case SmbRlapsEnum : return "SmbRlaps";
     352                case SmbRlapslgmEnum : return "SmbRlapslgm";
    319353                case SmbRunoffaltiEnum : return "SmbRunoffalti";
    320354                case SmbRunoffgradEnum : return "SmbRunoffgrad";
    … …  
    731765                case ClosedEnum : return "Closed";
    732766                case ColinearEnum : return "Colinear";
    733                 case ConstantsGEnum : return "ConstantsG";
    734                 case ConstantsReferencetemperatureEnum : return "ConstantsReferencetemperature";
    735767                case ConstraintsEnum : return "Constraints";
    736768                case ContactEnum : return "Contact";
    … …  
    826858                case HydrologyDCEfficientAnalysisEnum : return "HydrologyDCEfficientAnalysis";
    827859                case HydrologydcEnum : return "Hydrologydc";
    828                 case HydrologydcEplColapseThicknessEnum : return "HydrologydcEplColapseThickness";
    829                 case HydrologydcEplCompressibilityEnum : return "HydrologydcEplCompressibility";
    830                 case HydrologydcEplConductivityEnum : return "HydrologydcEplConductivity";
    831                 case HydrologydcEplInitialThicknessEnum : return "HydrologydcEplInitialThickness";
    832                 case HydrologydcEplMaxThicknessEnum : return "HydrologydcEplMaxThickness";
    833                 case HydrologydcEplPorosityEnum : return "HydrologydcEplPorosity";
    834860                case HydrologydcEplThicknessStackedEnum : return "HydrologydcEplThicknessStacked";
    835861                case HydrologydcEplThicknessEnum : return "HydrologydcEplThickness";
    836862                case HydrologyDCInefficientAnalysisEnum : return "HydrologyDCInefficientAnalysis";
    837                 case HydrologydcSedimentCompressibilityEnum : return "HydrologydcSedimentCompressibility";
    838                 case HydrologydcSedimentPorosityEnum : return "HydrologydcSedimentPorosity";
    839                 case HydrologydcSedimentThicknessEnum : return "HydrologydcSedimentThickness";
    840                 case HydrologydcWaterCompressibilityEnum : return "HydrologydcWaterCompressibility";
    841863                case HydrologyShreveAnalysisEnum : return "HydrologyShreveAnalysis";
    842864                case HydrologyshreveEnum : return "Hydrologyshreve";
    … …  
    897919                case MatdamageiceEnum : return "Matdamageice";
    898920                case MatenhancediceEnum : return "Matenhancedice";
    899                 case MaterialsBetaEnum : return "MaterialsBeta";
    900                 case MaterialsEarthDensityEnum : return "MaterialsEarthDensity";
     921                case MatestarEnum : return "Matestar";
    901922                case MaterialsEnum : return "Materials";
    902                 case MaterialsHeatcapacityEnum : return "MaterialsHeatcapacity";
    903                 case MaterialsLatentheatEnum : return "MaterialsLatentheat";
    904                 case MaterialsLithosphereDensityEnum : return "MaterialsLithosphereDensity";
    905                 case MaterialsLithosphereShearModulusEnum : return "MaterialsLithosphereShearModulus";
    906                 case MaterialsMantleDensityEnum : return "MaterialsMantleDensity";
    907                 case MaterialsMantleShearModulusEnum : return "MaterialsMantleShearModulus";
    908                 case MaterialsMeltingpointEnum : return "MaterialsMeltingpoint";
    909                 case MaterialsMixedLayerCapacityEnum : return "MaterialsMixedLayerCapacity";
    910                 case MaterialsMuWaterEnum : return "MaterialsMuWater";
    911                 case MaterialsRheologyLawEnum : return "MaterialsRheologyLaw";
    912                 case MaterialsRhoFreshwaterEnum : return "MaterialsRhoFreshwater";
    913                 case MaterialsRhoSeawaterEnum : return "MaterialsRhoSeawater";
    914                 case MaterialsTemperateiceconductivityEnum : return "MaterialsTemperateiceconductivity";
    915                 case MaterialsThermalconductivityEnum : return "MaterialsThermalconductivity";
    916                 case MaterialsThermalExchangeVelocityEnum : return "MaterialsThermalExchangeVelocity";
    917                 case MatestarEnum : return "Matestar";
    918923                case MaticeEnum : return "Matice";
    919924                case MatlithoEnum : return "Matlitho";
    920                 case MatparEnum : return "Matpar";
    921925                case MatrixParamEnum : return "MatrixParam";
    922926                case MaxAbsVxEnum : return "MaxAbsVx";
    … …  
    11101114                case SMBcomponentsEnum : return "SMBcomponents";
    11111115                case SMBd18opddEnum : return "SMBd18opdd";
    1112                 case SmbDesfacEnum : return "SmbDesfac";
    1113                 case SmbDpermilEnum : return "SmbDpermil";
    11141116                case SmbDzAddEnum : return "SmbDzAdd";
    11151117                case SmbFACEnum : return "SmbFAC";
    … …  
    11251127                case SMBpddSicopolisEnum : return "SMBpddSicopolis";
    11261128                case SMBgradientscomponentsEnum : return "SMBgradientscomponents";
    1127                 case SmbRdlEnum : return "SmbRdl";
    1128                 case SmbRlapsEnum : return "SmbRlaps";
    1129                 case SmbRlapslgmEnum : return "SmbRlapslgm";
    11301129                case SmbSolutionEnum : return "SmbSolution";
    11311130                case SmoothAnalysisEnum : return "SmoothAnalysis";

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

    r23540 r23644  
    101101              else if (strcmp(name,"CalvingMinthickness")==0) return CalvingMinthicknessEnum;
    102102              else if (strcmp(name,"ConfigurationType")==0) return ConfigurationTypeEnum;
     103              else if (strcmp(name,"ConstantsG")==0) return ConstantsGEnum;
     104              else if (strcmp(name,"ConstantsReferencetemperature")==0) return ConstantsReferencetemperatureEnum;
    103105              else if (strcmp(name,"ConstantsYts")==0) return ConstantsYtsEnum;
    104106              else if (strcmp(name,"DamageC1")==0) return DamageC1Enum;
    … …  
    135137              else if (strcmp(name,"FrictionF")==0) return FrictionFEnum;
    136138              else if (strcmp(name,"FrictionGamma")==0) return FrictionGammaEnum;
    137               else if (strcmp(name,"FrictionLaw")==0) return FrictionLawEnum;
    138               else if (strcmp(name,"FrictionPseudoplasticityExponent")==0) return FrictionPseudoplasticityExponentEnum;
    139139         else stage=2;
    140140   }
    141141   if(stage==2){
    142               if (strcmp(name,"FrictionThresholdSpeed")==0) return FrictionThresholdSpeedEnum;
     142              if (strcmp(name,"FrictionLaw")==0) return FrictionLawEnum;
     143              else if (strcmp(name,"FrictionPseudoplasticityExponent")==0) return FrictionPseudoplasticityExponentEnum;
     144              else if (strcmp(name,"FrictionThresholdSpeed")==0) return FrictionThresholdSpeedEnum;
    143145              else if (strcmp(name,"FrictionDelta")==0) return FrictionDeltaEnum;
    144146              else if (strcmp(name,"FrictionVoidRatio")==0) return FrictionVoidRatioEnum;
    … …  
    149151              else if (strcmp(name,"HydrologydcEplflipLock")==0) return HydrologydcEplflipLockEnum;
    150152              else if (strcmp(name,"HydrologydcEplThickComp")==0) return HydrologydcEplThickCompEnum;
     153              else if (strcmp(name,"HydrologydcEplColapseThickness")==0) return HydrologydcEplColapseThicknessEnum;
     154              else if (strcmp(name,"HydrologydcEplCompressibility")==0) return HydrologydcEplCompressibilityEnum;
     155              else if (strcmp(name,"HydrologydcEplConductivity")==0) return HydrologydcEplConductivityEnum;
     156              else if (strcmp(name,"HydrologydcEplInitialThickness")==0) return HydrologydcEplInitialThicknessEnum;
     157              else if (strcmp(name,"HydrologydcEplMaxThickness")==0) return HydrologydcEplMaxThicknessEnum;
     158              else if (strcmp(name,"HydrologydcEplPorosity")==0) return HydrologydcEplPorosityEnum;
    151159              else if (strcmp(name,"HydrologydcIsefficientlayer")==0) return HydrologydcIsefficientlayerEnum;
    152160              else if (strcmp(name,"HydrologydcLeakageFactor")==0) return HydrologydcLeakageFactorEnum;
     161              else if (strcmp(name,"HydrologydcSedimentCompressibility")==0) return HydrologydcSedimentCompressibilityEnum;
     162              else if (strcmp(name,"HydrologydcSedimentPorosity")==0) return HydrologydcSedimentPorosityEnum;
     163              else if (strcmp(name,"HydrologydcSedimentThickness")==0) return HydrologydcSedimentThicknessEnum;
    153164              else if (strcmp(name,"HydrologydcMaxIter")==0) return HydrologydcMaxIterEnum;
    154165              else if (strcmp(name,"HydrologydcPenaltyFactor")==0) return HydrologydcPenaltyFactorEnum;
     166              else if (strcmp(name,"HydrologydcWaterCompressibility")==0) return HydrologydcWaterCompressibilityEnum;
    155167              else if (strcmp(name,"HydrologydcPenaltyLock")==0) return HydrologydcPenaltyLockEnum;
    156168              else if (strcmp(name,"HydrologydcRelTol")==0) return HydrologydcRelTolEnum;
    … …  
    219231              else if (strcmp(name,"MasstransportRequestedOutputs")==0) return MasstransportRequestedOutputsEnum;
    220232              else if (strcmp(name,"MasstransportStabilization")==0) return MasstransportStabilizationEnum;
     233              else if (strcmp(name,"MaterialsBeta")==0) return MaterialsBetaEnum;
     234              else if (strcmp(name,"MaterialsEarthDensity")==0) return MaterialsEarthDensityEnum;
     235              else if (strcmp(name,"MaterialsHeatcapacity")==0) return MaterialsHeatcapacityEnum;
     236              else if (strcmp(name,"MaterialsLatentheat")==0) return MaterialsLatentheatEnum;
     237              else if (strcmp(name,"MaterialsLithosphereDensity")==0) return MaterialsLithosphereDensityEnum;
     238              else if (strcmp(name,"MaterialsLithosphereShearModulus")==0) return MaterialsLithosphereShearModulusEnum;
     239              else if (strcmp(name,"MaterialsMantleDensity")==0) return MaterialsMantleDensityEnum;
     240              else if (strcmp(name,"MaterialsMantleShearModulus")==0) return MaterialsMantleShearModulusEnum;
     241              else if (strcmp(name,"MaterialsMeltingpoint")==0) return MaterialsMeltingpointEnum;
     242              else if (strcmp(name,"MaterialsMixedLayerCapacity")==0) return MaterialsMixedLayerCapacityEnum;
     243              else if (strcmp(name,"MaterialsMuWater")==0) return MaterialsMuWaterEnum;
     244              else if (strcmp(name,"MaterialsRheologyLaw")==0) return MaterialsRheologyLawEnum;
    221245              else if (strcmp(name,"MaterialsRhoIce")==0) return MaterialsRhoIceEnum;
     246              else if (strcmp(name,"MaterialsRhoFreshwater")==0) return MaterialsRhoFreshwaterEnum;
     247              else if (strcmp(name,"MaterialsRhoSeawater")==0) return MaterialsRhoSeawaterEnum;
     248              else if (strcmp(name,"MaterialsTemperateiceconductivity")==0) return MaterialsTemperateiceconductivityEnum;
     249              else if (strcmp(name,"MaterialsThermalconductivity")==0) return MaterialsThermalconductivityEnum;
     250              else if (strcmp(name,"MaterialsThermalExchangeVelocity")==0) return MaterialsThermalExchangeVelocityEnum;
    222251              else if (strcmp(name,"MeltingOffset")==0) return MeltingOffsetEnum;
    223252              else if (strcmp(name,"MeshAverageVertexConnectivity")==0) return MeshAverageVertexConnectivityEnum;
    … …  
    231260              else if (strcmp(name,"OceanGridNy")==0) return OceanGridNyEnum;
    232261              else if (strcmp(name,"OceanGridX")==0) return OceanGridXEnum;
    233               else if (strcmp(name,"OceanGridY")==0) return OceanGridYEnum;
     262         else stage=3;
     263   }
     264   if(stage==3){
     265              if (strcmp(name,"OceanGridY")==0) return OceanGridYEnum;
    234266              else if (strcmp(name,"OutputBufferPointer")==0) return OutputBufferPointerEnum;
    235267              else if (strcmp(name,"OutputBufferSizePointer")==0) return OutputBufferSizePointerEnum;
    … …  
    260292              else if (strcmp(name,"SealevelriseFluidLove")==0) return SealevelriseFluidLoveEnum;
    261293              else if (strcmp(name,"SealevelriseGElastic")==0) return SealevelriseGElasticEnum;
    262          else stage=3;
    263    }
    264    if(stage==3){
    265               if (strcmp(name,"SealevelriseGeodetic")==0) return SealevelriseGeodeticEnum;
     294              else if (strcmp(name,"SealevelriseGeodetic")==0) return SealevelriseGeodeticEnum;
    266295              else if (strcmp(name,"SealevelriseGeodeticRunFrequency")==0) return SealevelriseGeodeticRunFrequencyEnum;
    267296              else if (strcmp(name,"SealevelriseHElastic")==0) return SealevelriseHElasticEnum;
    … …  
    294323              else if (strcmp(name,"SmbAIce")==0) return SmbAIceEnum;
    295324              else if (strcmp(name,"SmbAIdx")==0) return SmbAIdxEnum;
     325              else if (strcmp(name,"SmbDesfac")==0) return SmbDesfacEnum;
     326              else if (strcmp(name,"SmbDpermil")==0) return SmbDpermilEnum;
    296327              else if (strcmp(name,"SmbDsnowIdx")==0) return SmbDsnowIdxEnum;
    297328              else if (strcmp(name,"SmbASnow")==0) return SmbASnowEnum;
    … …  
    323354              else if (strcmp(name,"SmbPfac")==0) return SmbPfacEnum;
    324355              else if (strcmp(name,"SmbRequestedOutputs")==0) return SmbRequestedOutputsEnum;
     356              else if (strcmp(name,"SmbRdl")==0) return SmbRdlEnum;
     357              else if (strcmp(name,"SmbRlaps")==0) return SmbRlapsEnum;
     358              else if (strcmp(name,"SmbRlapslgm")==0) return SmbRlapslgmEnum;
    325359              else if (strcmp(name,"SmbRunoffalti")==0) return SmbRunoffaltiEnum;
    326360              else if (strcmp(name,"SmbRunoffgrad")==0) return SmbRunoffgradEnum;
    … …  
    349383              else if (strcmp(name,"StressbalanceRestol")==0) return StressbalanceRestolEnum;
    350384              else if (strcmp(name,"StressbalanceRiftPenaltyThreshold")==0) return StressbalanceRiftPenaltyThresholdEnum;
    351               else if (strcmp(name,"StressbalanceShelfDampening")==0) return StressbalanceShelfDampeningEnum;
     385         else stage=4;
     386   }
     387   if(stage==4){
     388              if (strcmp(name,"StressbalanceShelfDampening")==0) return StressbalanceShelfDampeningEnum;
    352389              else if (strcmp(name,"ThermalIsdynamicbasalspc")==0) return ThermalIsdynamicbasalspcEnum;
    353390              else if (strcmp(name,"ThermalIsenthalpy")==0) return ThermalIsenthalpyEnum;
    … …  
    383420              else if (strcmp(name,"TransientIshydrology")==0) return TransientIshydrologyEnum;
    384421              else if (strcmp(name,"TransientIsmasstransport")==0) return TransientIsmasstransportEnum;
    385          else stage=4;
    386    }
    387    if(stage==4){
    388               if (strcmp(name,"TransientIsmovingfront")==0) return TransientIsmovingfrontEnum;
     422              else if (strcmp(name,"TransientIsmovingfront")==0) return TransientIsmovingfrontEnum;
    389423              else if (strcmp(name,"TransientIsoceancoupling")==0) return TransientIsoceancouplingEnum;
    390424              else if (strcmp(name,"TransientIsslr")==0) return TransientIsslrEnum;
    … …  
    472506              else if (strcmp(name,"FrictionEffectivePressure")==0) return FrictionEffectivePressureEnum;
    473507              else if (strcmp(name,"FrictionM")==0) return FrictionMEnum;
    474               else if (strcmp(name,"FrictionP")==0) return FrictionPEnum;
     508         else stage=5;
     509   }
     510   if(stage==5){
     511              if (strcmp(name,"FrictionP")==0) return FrictionPEnum;
    475512              else if (strcmp(name,"FrictionPressureAdjustedTemperature")==0) return FrictionPressureAdjustedTemperatureEnum;
    476513              else if (strcmp(name,"FrictionQ")==0) return FrictionQEnum;
    … …  
    506543              else if (strcmp(name,"HydrologyWaterVy")==0) return HydrologyWaterVyEnum;
    507544              else if (strcmp(name,"HydrologyDrainageRate")==0) return HydrologyDrainageRateEnum;
    508          else stage=5;
    509    }
    510    if(stage==5){
    511               if (strcmp(name,"Ice")==0) return IceEnum;
     545              else if (strcmp(name,"Ice")==0) return IceEnum;
    512546              else if (strcmp(name,"IceMaskNodeActivation")==0) return IceMaskNodeActivationEnum;
    513547              else if (strcmp(name,"Input")==0) return InputEnum;
    … …  
    595629              else if (strcmp(name,"SmbDzMin")==0) return SmbDzMinEnum;
    596630              else if (strcmp(name,"SmbDzTop")==0) return SmbDzTopEnum;
    597               else if (strcmp(name,"SmbEAir")==0) return SmbEAirEnum;
     631         else stage=6;
     632   }
     633   if(stage==6){
     634              if (strcmp(name,"SmbEAir")==0) return SmbEAirEnum;
    598635              else if (strcmp(name,"SmbEC")==0) return SmbECEnum;
    599636              else if (strcmp(name,"SmbECini")==0) return SmbECiniEnum;
    … …  
    629666              else if (strcmp(name,"SmbSmbCorr")==0) return SmbSmbCorrEnum;
    630667              else if (strcmp(name,"SmbTa")==0) return SmbTaEnum;
    631          else stage=6;
    632    }
    633    if(stage==6){
    634               if (strcmp(name,"SmbTemperaturesAnomaly")==0) return SmbTemperaturesAnomalyEnum;
     668              else if (strcmp(name,"SmbTemperaturesAnomaly")==0) return SmbTemperaturesAnomalyEnum;
    635669              else if (strcmp(name,"SmbTemperaturesLgm")==0) return SmbTemperaturesLgmEnum;
    636670              else if (strcmp(name,"SmbTemperaturesPresentday")==0) return SmbTemperaturesPresentdayEnum;
    … …  
    718752              else if (strcmp(name,"AndroidFrictionCoefficient")==0) return AndroidFrictionCoefficientEnum;
    719753              else if (strcmp(name,"Arrhenius")==0) return ArrheniusEnum;
    720               else if (strcmp(name,"AutodiffJacobian")==0) return AutodiffJacobianEnum;
     754         else stage=7;
     755   }
     756   if(stage==7){
     757              if (strcmp(name,"AutodiffJacobian")==0) return AutodiffJacobianEnum;
    721758              else if (strcmp(name,"Balancethickness2Analysis")==0) return Balancethickness2AnalysisEnum;
    722759              else if (strcmp(name,"Balancethickness2Solution")==0) return Balancethickness2SolutionEnum;
    … …  
    746783              else if (strcmp(name,"Closed")==0) return ClosedEnum;
    747784              else if (strcmp(name,"Colinear")==0) return ColinearEnum;
    748               else if (strcmp(name,"ConstantsG")==0) return ConstantsGEnum;
    749               else if (strcmp(name,"ConstantsReferencetemperature")==0) return ConstantsReferencetemperatureEnum;
    750785              else if (strcmp(name,"Constraints")==0) return ConstraintsEnum;
    751786              else if (strcmp(name,"Contact")==0) return ContactEnum;
    752787              else if (strcmp(name,"Contour")==0) return ContourEnum;
    753788              else if (strcmp(name,"Contours")==0) return ContoursEnum;
    754          else stage=7;
    755    }
    756    if(stage==7){
    757               if (strcmp(name,"ControlInput")==0) return ControlInputEnum;
     789              else if (strcmp(name,"ControlInput")==0) return ControlInputEnum;
    758790              else if (strcmp(name,"ControlInputValues")==0) return ControlInputValuesEnum;
    759791              else if (strcmp(name,"ControlInputMins")==0) return ControlInputMinsEnum;
    … …  
    843875              else if (strcmp(name,"HydrologyBasalFlux")==0) return HydrologyBasalFluxEnum;
    844876              else if (strcmp(name,"HydrologyDCEfficientAnalysis")==0) return HydrologyDCEfficientAnalysisEnum;
    845               else if (strcmp(name,"Hydrologydc")==0) return HydrologydcEnum;
    846               else if (strcmp(name,"HydrologydcEplColapseThickness")==0) return HydrologydcEplColapseThicknessEnum;
    847               else if (strcmp(name,"HydrologydcEplCompressibility")==0) return HydrologydcEplCompressibilityEnum;
    848               else if (strcmp(name,"HydrologydcEplConductivity")==0) return HydrologydcEplConductivityEnum;
    849               else if (strcmp(name,"HydrologydcEplInitialThickness")==0) return HydrologydcEplInitialThicknessEnum;
    850               else if (strcmp(name,"HydrologydcEplMaxThickness")==0) return HydrologydcEplMaxThicknessEnum;
    851               else if (strcmp(name,"HydrologydcEplPorosity")==0) return HydrologydcEplPorosityEnum;
     877         else stage=8;
     878   }
     879   if(stage==8){
     880              if (strcmp(name,"Hydrologydc")==0) return HydrologydcEnum;
    852881              else if (strcmp(name,"HydrologydcEplThicknessStacked")==0) return HydrologydcEplThicknessStackedEnum;
    853882              else if (strcmp(name,"HydrologydcEplThickness")==0) return HydrologydcEplThicknessEnum;
    854883              else if (strcmp(name,"HydrologyDCInefficientAnalysis")==0) return HydrologyDCInefficientAnalysisEnum;
    855               else if (strcmp(name,"HydrologydcSedimentCompressibility")==0) return HydrologydcSedimentCompressibilityEnum;
    856               else if (strcmp(name,"HydrologydcSedimentPorosity")==0) return HydrologydcSedimentPorosityEnum;
    857               else if (strcmp(name,"HydrologydcSedimentThickness")==0) return HydrologydcSedimentThicknessEnum;
    858               else if (strcmp(name,"HydrologydcWaterCompressibility")==0) return HydrologydcWaterCompressibilityEnum;
    859884              else if (strcmp(name,"HydrologyShreveAnalysis")==0) return HydrologyShreveAnalysisEnum;
    860885              else if (strcmp(name,"Hydrologyshreve")==0) return HydrologyshreveEnum;
    … …  
    875900              else if (strcmp(name,"Intersect")==0) return IntersectEnum;
    876901              else if (strcmp(name,"IntExternalResult")==0) return IntExternalResultEnum;
    877          else stage=8;
    878    }
    879    if(stage==8){
    880               if (strcmp(name,"IntInput")==0) return IntInputEnum;
     902              else if (strcmp(name,"IntInput")==0) return IntInputEnum;
    881903              else if (strcmp(name,"IntMatExternalResult")==0) return IntMatExternalResultEnum;
    882904              else if (strcmp(name,"IntMatParam")==0) return IntMatParamEnum;
    … …  
    918940              else if (strcmp(name,"Matdamageice")==0) return MatdamageiceEnum;
    919941              else if (strcmp(name,"Matenhancedice")==0) return MatenhancediceEnum;
    920               else if (strcmp(name,"MaterialsBeta")==0) return MaterialsBetaEnum;
    921               else if (strcmp(name,"MaterialsEarthDensity")==0) return MaterialsEarthDensityEnum;
     942              else if (strcmp(name,"Matestar")==0) return MatestarEnum;
    922943              else if (strcmp(name,"Materials")==0) return MaterialsEnum;
    923               else if (strcmp(name,"MaterialsHeatcapacity")==0) return MaterialsHeatcapacityEnum;
    924               else if (strcmp(name,"MaterialsLatentheat")==0) return MaterialsLatentheatEnum;
    925               else if (strcmp(name,"MaterialsLithosphereDensity")==0) return MaterialsLithosphereDensityEnum;
    926               else if (strcmp(name,"MaterialsLithosphereShearModulus")==0) return MaterialsLithosphereShearModulusEnum;
    927               else if (strcmp(name,"MaterialsMantleDensity")==0) return MaterialsMantleDensityEnum;
    928               else if (strcmp(name,"MaterialsMantleShearModulus")==0) return MaterialsMantleShearModulusEnum;
    929               else if (strcmp(name,"MaterialsMeltingpoint")==0) return MaterialsMeltingpointEnum;
    930               else if (strcmp(name,"MaterialsMixedLayerCapacity")==0) return MaterialsMixedLayerCapacityEnum;
    931               else if (strcmp(name,"MaterialsMuWater")==0) return MaterialsMuWaterEnum;
    932               else if (strcmp(name,"MaterialsRheologyLaw")==0) return MaterialsRheologyLawEnum;
    933               else if (strcmp(name,"MaterialsRhoFreshwater")==0) return MaterialsRhoFreshwaterEnum;
    934               else if (strcmp(name,"MaterialsRhoSeawater")==0) return MaterialsRhoSeawaterEnum;
    935               else if (strcmp(name,"MaterialsTemperateiceconductivity")==0) return MaterialsTemperateiceconductivityEnum;
    936               else if (strcmp(name,"MaterialsThermalconductivity")==0) return MaterialsThermalconductivityEnum;
    937               else if (strcmp(name,"MaterialsThermalExchangeVelocity")==0) return MaterialsThermalExchangeVelocityEnum;
    938               else if (strcmp(name,"Matestar")==0) return MatestarEnum;
    939944              else if (strcmp(name,"Matice")==0) return MaticeEnum;
    940945              else if (strcmp(name,"Matlitho")==0) return MatlithoEnum;
    941               else if (strcmp(name,"Matpar")==0) return MatparEnum;
    942946              else if (strcmp(name,"MatrixParam")==0) return MatrixParamEnum;
    943947              else if (strcmp(name,"MaxAbsVx")==0) return MaxAbsVxEnum;
    … …  
    994998              else if (strcmp(name,"Outputdefinition21")==0) return Outputdefinition21Enum;
    995999              else if (strcmp(name,"Outputdefinition22")==0) return Outputdefinition22Enum;
    996               else if (strcmp(name,"Outputdefinition23")==0) return Outputdefinition23Enum;
     1000         else stage=9;
     1001   }
     1002   if(stage==9){
     1003              if (strcmp(name,"Outputdefinition23")==0) return Outputdefinition23Enum;
    9971004              else if (strcmp(name,"Outputdefinition24")==0) return Outputdefinition24Enum;
    9981005              else if (strcmp(name,"Outputdefinition25")==0) return Outputdefinition25Enum;
    9991006              else if (strcmp(name,"Outputdefinition26")==0) return Outputdefinition26Enum;
    1000          else stage=9;
    1001    }
    1002    if(stage==9){
    1003               if (strcmp(name,"Outputdefinition27")==0) return Outputdefinition27Enum;
     1007              else if (strcmp(name,"Outputdefinition27")==0) return Outputdefinition27Enum;
    10041008              else if (strcmp(name,"Outputdefinition28")==0) return Outputdefinition28Enum;
    10051009              else if (strcmp(name,"Outputdefinition29")==0) return Outputdefinition29Enum;
    … …  
    11171121              else if (strcmp(name,"SealevelNmotion")==0) return SealevelNmotionEnum;
    11181122              else if (strcmp(name,"SealevelriseAnalysis")==0) return SealevelriseAnalysisEnum;
    1119               else if (strcmp(name,"SealevelriseSolution")==0) return SealevelriseSolutionEnum;
     1123         else stage=10;
     1124   }
     1125   if(stage==10){
     1126              if (strcmp(name,"SealevelriseSolution")==0) return SealevelriseSolutionEnum;
    11201127              else if (strcmp(name,"SealevelriseStericRate")==0) return SealevelriseStericRateEnum;
    11211128              else if (strcmp(name,"SealevelUmotion")==0) return SealevelUmotionEnum;
    11221129              else if (strcmp(name,"SedimentHeadStacked")==0) return SedimentHeadStackedEnum;
    1123          else stage=10;
    1124    }
    1125    if(stage==10){
    1126               if (strcmp(name,"SedimentHead")==0) return SedimentHeadEnum;
     1130              else if (strcmp(name,"SedimentHead")==0) return SedimentHeadEnum;
    11271131              else if (strcmp(name,"Seg")==0) return SegEnum;
    11281132              else if (strcmp(name,"SegInput")==0) return SegInputEnum;
    … …  
    11371141              else if (strcmp(name,"SMBcomponents")==0) return SMBcomponentsEnum;
    11381142              else if (strcmp(name,"SMBd18opdd")==0) return SMBd18opddEnum;
    1139               else if (strcmp(name,"SmbDesfac")==0) return SmbDesfacEnum;
    1140               else if (strcmp(name,"SmbDpermil")==0) return SmbDpermilEnum;
    11411143              else if (strcmp(name,"SmbDzAdd")==0) return SmbDzAddEnum;
    11421144              else if (strcmp(name,"SmbFAC")==0) return SmbFACEnum;
    … …  
    11521154              else if (strcmp(name,"SMBpddSicopolis")==0) return SMBpddSicopolisEnum;
    11531155              else if (strcmp(name,"SMBgradientscomponents")==0) return SMBgradientscomponentsEnum;
    1154               else if (strcmp(name,"SmbRdl")==0) return SmbRdlEnum;
    1155               else if (strcmp(name,"SmbRlaps")==0) return SmbRlapsEnum;
    1156               else if (strcmp(name,"SmbRlapslgm")==0) return SmbRlapslgmEnum;
    11571156              else if (strcmp(name,"SmbSolution")==0) return SmbSolutionEnum;
    11581157              else if (strcmp(name,"SmoothAnalysis")==0) return SmoothAnalysisEnum;
Note: See TracChangeset for help on using the changeset viewer.