Changeset 27856 for issm/trunk-jpl/src


Ignore:
Timestamp:
07/26/23 09:41:33 (20 months ago)
Author:
rueckamp
Message:

CHG: Replace SMBdebrisML with SMBdebrisEvatt; adding new options for SMBdebrisEvatt

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

Legend:

Unmodified
Added
Removed

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

    r27852 r27856  
    242242                        }
    243243                        break;
    244                 case SMBdebrisMLEnum:
    245                         iomodel->FetchDataToInput(inputs,elements,"md.initialization.debris",DebrisThicknessEnum);
    246                         break;
     244                case SMBdebrisEvattEnum:
     245                        iomodel->FetchDataToInput(inputs,elements,"md.initialization.debris",DebrisThicknessEnum);
     246                        iomodel->FetchDataToInput(inputs,elements,"md.smb.s0t",SmbS0tEnum);
     247                        iomodel->FetchDataToInput(inputs,elements,"md.smb.snowheight",SmbSnowheightEnum);
     248                        iomodel->FetchDataToDatasetInput(inputs,elements,"md.smb.temperature",SmbMonthlytemperaturesEnum);
     249                        iomodel->FetchDataToDatasetInput(inputs,elements,"md.smb.precipitation",SmbPrecipitationEnum);
     250                        iomodel->FetchDataToDatasetInput(inputs,elements,"md.smb.dsradiation",SmbMonthlydsradiationEnum);
     251                        iomodel->FetchDataToDatasetInput(inputs,elements,"md.smb.dlradiation",SmbMonthlydlradiationEnum);
     252                        iomodel->FetchDataToDatasetInput(inputs,elements,"md.smb.windspeed",SmbMonthlywindspeedEnum);
     253                        iomodel->FetchDataToDatasetInput(inputs,elements,"md.smb.airhumidity",SmbMonthlyairhumidityEnum);
     254                        iomodel->FetchDataToInput(inputs,elements,"md.smb.precipitation_anomaly",SmbPrecipitationsAnomalyEnum);
     255                        iomodel->FetchDataToInput(inputs,elements,"md.smb.temperature_anomaly",SmbTemperaturesAnomalyEnum);
     256                        iomodel->FetchDataToInput(inputs,elements,"md.smb.dsradiation_anomaly",SmbDsradiationAnomalyEnum);
     257                        iomodel->FetchDataToInput(inputs,elements,"md.smb.dlradiation_anomaly",SmbDlradiationAnomalyEnum);
     258                        iomodel->FetchDataToInput(inputs,elements,"md.smb.windspeed_anomaly",SmbWindspeedAnomalyEnum);
     259                        iomodel->FetchDataToInput(inputs,elements,"md.smb.airhumidity_anomaly",SmbAirhumidityAnomalyEnum);
     260                        break;
    247261                default:
    248262                        _error_("Surface mass balance model "<<EnumToStringx(smb_model)<<" not supported yet");
    … …  
    473487                        /*Nothing to add to parameters*/
    474488                        break;
    475                 case SMBdebrisMLEnum:
     489                case SMBdebrisEvattEnum:
    476490                        /*Nothing to add to parameters*/
    477491                        break;
    … …  
    573587                        #endif //_HAVE_SEMIC_
    574588                        break;
    575                 case SMBdebrisMLEnum:
    576                         if(VerboseSolution())_printf0_("        call smb debris Mayer & Liculli module\n");
    577                         SmbDebrisMLx(femmodel);
    578                         break;
     589                case SMBdebrisEvattEnum:
     590                        if(VerboseSolution())_printf0_("        call smb Evatt debris module\n");
     591                        SmbDebrisEvattx(femmodel);
     592                        break;
    579593                default:
    580594                        _error_("Surface mass balance model "<<EnumToStringx(smb_model)<<" not supported yet");

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

    r27852 r27856  
    37293729}
    37303730/*}}}*/
     3731void       Element::SmbDebrisEvatt(){/*{{{*/
     3732
     3733        const int NUM_VERTICES          = this->GetNumberOfVertices();
     3734        const int NUM_VERTICES_DAYS_PER_YEAR  = NUM_VERTICES * 365; // 365 FIXME
     3735
     3736        int             i,vertexlids[MAXVERTICES];;
     3737        IssmDouble* smb=xNew<IssmDouble>(NUM_VERTICES);
     3738        IssmDouble* melt=xNew<IssmDouble>(NUM_VERTICES);
     3739        IssmDouble* summermelt=xNew<IssmDouble>(NUM_VERTICES);
     3740        IssmDouble* albedo=xNew<IssmDouble>(NUM_VERTICES);
     3741        IssmDouble* summeralbedo=xNew<IssmDouble>(NUM_VERTICES);
     3742        IssmDouble* accu=xNew<IssmDouble>(NUM_VERTICES);
     3743       
     3744        // climate inputs
     3745        IssmDouble* temperature=xNew<IssmDouble>(NUM_VERTICES_DAYS_PER_YEAR);
     3746        IssmDouble* precip=xNew<IssmDouble>(NUM_VERTICES_DAYS_PER_YEAR);
     3747        IssmDouble* lw=xNew<IssmDouble>(NUM_VERTICES_DAYS_PER_YEAR);
     3748        IssmDouble* sw=xNew<IssmDouble>(NUM_VERTICES_DAYS_PER_YEAR);
     3749        IssmDouble* wind=xNew<IssmDouble>(NUM_VERTICES_DAYS_PER_YEAR);
     3750        IssmDouble* humidity=xNew<IssmDouble>(NUM_VERTICES_DAYS_PER_YEAR);
     3751        IssmDouble* yearlytemperatures=xNew<IssmDouble>(NUM_VERTICES); memset(yearlytemperatures, 0., NUM_VERTICES*sizeof(IssmDouble));
     3752        IssmDouble* p_ampl=xNew<IssmDouble>(NUM_VERTICES);
     3753        IssmDouble* t_ampl=xNew<IssmDouble>(NUM_VERTICES);
     3754        IssmDouble* lw_ampl=xNew<IssmDouble>(NUM_VERTICES);
     3755        IssmDouble* sw_ampl=xNew<IssmDouble>(NUM_VERTICES);
     3756        IssmDouble* wind_ampl=xNew<IssmDouble>(NUM_VERTICES);
     3757        IssmDouble* humidity_ampl=xNew<IssmDouble>(NUM_VERTICES);
     3758
     3759        IssmDouble* surface=xNew<IssmDouble>(NUM_VERTICES);
     3760        IssmDouble* s0t=xNew<IssmDouble>(NUM_VERTICES);
     3761        IssmDouble* snowheight=xNew<IssmDouble>(NUM_VERTICES);
     3762        IssmDouble* debriscover=xNew<IssmDouble>(NUM_VERTICES);
     3763        IssmDouble rho_water,rho_ice,Tf,debris,debris_here;
     3764        IssmDouble qlaps,rlaps,dsgrad,dlgrad,windspeedgrad,humiditygrad,Tm;
     3765        IssmDouble inv_twelve=1./365.;
     3766        IssmDouble time,yts,time_yr,lambda;
     3767        IssmDouble DailyMelt,CleanIceDailyMelt, CumDailyMelt=0,CleanIceMelt,CumDailySummerMelt=0;
     3768        IssmDouble MeanAlbedo=0, MeanSummerAlbedo=0;
     3769        bool isdebris,isAnderson,iscryokarst;
     3770        this->parameters->FindParam(&isdebris,TransientIsdebrisEnum);
     3771        this->parameters->FindParam(&isAnderson,SmbDebrisIsAndersonEnum);
     3772        this->parameters->FindParam(&iscryokarst,SmbDebrisIsCryokarstEnum);
     3773        IssmDouble PhiD=0.,p;
     3774        IssmDouble icealbedo=this->FindParam(SmbIcealbedoEnum);
     3775        IssmDouble snowalbedo=this->FindParam(SmbSnowalbedoEnum);
     3776        IssmDouble debrisalbedo=this->FindParam(SmbDebrisalbedoEnum);
     3777        IssmDouble Lm=this->FindParam(MaterialsLatentheatEnum);
     3778        IssmDouble D0=this->FindParam(SmbDebrisAndersonD0Enum);
     3779        int step;
     3780        this->FindParam(&step,StepEnum);
     3781
     3782        // cryokarst
     3783        int dim=1,domaintype;
     3784        this->parameters->FindParam(&domaintype,DomainTypeEnum);
     3785        if(domaintype!=Domain2DverticalEnum){
     3786                        dim=2;
     3787        }
     3788        IssmDouble taud_plus=110e3, taud_minus=60e3;
     3789        IssmDouble taud, slope, gravity, taudx, taudy;
     3790        this->parameters->FindParam(&gravity,ConstantsGEnum);
     3791        IssmDouble* slopex         = xNew<IssmDouble>(NUM_VERTICES);
     3792        IssmDouble* slopey         = xNew<IssmDouble>(NUM_VERTICES);
     3793        IssmDouble* icethickness   = xNew<IssmDouble>(NUM_VERTICES);
     3794
     3795        /*Get material parameters :*/
     3796        rho_water=this->FindParam(MaterialsRhoSeawaterEnum);
     3797        rho_ice=this->FindParam(MaterialsRhoIceEnum);
     3798        IssmDouble sconv=(rho_water/rho_ice);
     3799        Tf=this->FindParam(MaterialsMeltingpointEnum);
     3800
     3801        /*Get parameters for height corrections*/
     3802        qlaps=this->FindParam(SmbDesfacEnum); // comment MR; on alpine galciers we dont have the desertification effect
     3803        rlaps=this->FindParam(SmbRlapsEnum);
     3804        dsgrad=this->FindParam(SmbSWgradEnum);
     3805        dlgrad=this->FindParam(SmbLWgradEnum);
     3806        windspeedgrad=this->FindParam(SmbWindspeedgradEnum);
     3807        humiditygrad=this->FindParam(SmbHumiditygradEnum);
     3808
     3809        /* Get time */
     3810        this->parameters->FindParam(&time,TimeEnum);
     3811        this->parameters->FindParam(&yts,ConstantsYtsEnum);
     3812        time_yr=floor(time/yts)*yts;
     3813
     3814        /*Get inputs*/
     3815        DatasetInput* tempday     =this->GetDatasetInput(SmbMonthlytemperaturesEnum); _assert_(tempday);
     3816        DatasetInput* precipday   =this->GetDatasetInput(SmbPrecipitationEnum);       _assert_(precipday);
     3817        DatasetInput* lwday       =this->GetDatasetInput(SmbMonthlydlradiationEnum); _assert_(lwday);
     3818        DatasetInput* swday       =this->GetDatasetInput(SmbMonthlydsradiationEnum);       _assert_(swday);
     3819        DatasetInput* windday     =this->GetDatasetInput(SmbMonthlywindspeedEnum); _assert_(windday);
     3820        DatasetInput* humidityday =this->GetDatasetInput(SmbMonthlyairhumidityEnum); _assert_(humidityday);
     3821
     3822        /*loop over vertices: */
     3823        Gauss* gauss=this->NewGauss();
     3824        for(int month=0;month<365;month++){
     3825                for(int iv=0;iv<NUM_VERTICES;iv++){
     3826                        gauss->GaussVertex(iv);
     3827                        tempday->GetInputValue(&temperature[iv*365+month],gauss,month);
     3828                        temperature[iv*365+month]=temperature[iv*365+month]-Tf; // conversion from Kelvin to celcius for PDD module
     3829                        precipday->GetInputValue(&precip[iv*365+month],gauss,month);
     3830                        precip[iv*365+month]=precip[iv*365+month]*yts; // from m/s to m/a
     3831                        lwday->GetInputValue(&lw[iv*365+month],gauss,month);
     3832                        swday->GetInputValue(&sw[iv*365+month],gauss,month);
     3833                        windday->GetInputValue(&wind[iv*365+month],gauss,month);
     3834                        humidityday->GetInputValue(&humidity[iv*365+month],gauss,month);
     3835                }
     3836        }
     3837
     3838        /*Recover info at the vertices: */
     3839        GetInputListOnVertices(&surface[0],SurfaceEnum);
     3840        GetInputListOnVertices(&s0t[0],SmbS0tEnum);
     3841        GetInputListOnVertices(&snowheight[0],SmbSnowheightEnum);
     3842        GetInputListOnVertices(&debriscover[0],DebrisThicknessEnum);
     3843        GetInputListOnVertices(&t_ampl[0],SmbTemperaturesAnomalyEnum);
     3844        GetInputListOnVertices(&p_ampl[0],SmbPrecipitationsAnomalyEnum);
     3845        GetInputListOnVertices(&lw_ampl[0],SmbDsradiationAnomalyEnum);
     3846        GetInputListOnVertices(&sw_ampl[0],SmbDlradiationAnomalyEnum);
     3847        GetInputListOnVertices(&wind_ampl[0],SmbWindspeedAnomalyEnum);
     3848        GetInputListOnVertices(&humidity_ampl[0],SmbAirhumidityAnomalyEnum);
     3849        if(iscryokarst){
     3850                GetInputListOnVertices(&slopex[0],SurfaceSlopeXEnum);
     3851                GetInputListOnVertices(&icethickness[0],ThicknessEnum);
     3852                if(dim==2){
     3853                        GetInputListOnVertices(&slopey[0],SurfaceSlopeYEnum);
     3854                }
     3855                taudx=rho_ice*gravity*icethickness[i]*slopex[i];
     3856                if(dim==2) taudy=rho_ice*gravity*icethickness[i]*slopey[i];
     3857                taud=sqrt(taudx*taudx+taudy*taudy);
     3858        }
     3859        IssmDouble Alphaeff,Alphaeff_cleanice;
     3860
     3861        /*measure the surface mass balance*/
     3862        for (int iv = 0; iv<NUM_VERTICES; iv++){
     3863
     3864                IssmDouble st=(surface[iv]-s0t[iv])/1000.;
     3865
     3866                int ismb_end=1;
     3867                if(isdebris & !isAnderson) ismb_end=2;
     3868                for (int ismb=0;ismb<ismb_end;ismb++){
     3869                        if(ismb==0){
     3870                                // calc a reference smb to identify accum and melt region; debris only develops in ablation area
     3871                                debris=0.;
     3872                                PhiD=0.;
     3873                                if(isAnderson) debris_here=debriscover[iv]; // store debris for later
     3874                        }else{
     3875                                // debris only develops in ablation area
     3876                                /*if((accu[iv]/yts-CleanIceMelt)<(-1e-2)/yts){
     3877                                        debris=debriscover[iv];
     3878                                }else{
     3879                                        debris=0.;
     3880                                }*/
     3881                                debris=0.;
     3882                                if(debris<=0.) debris=0.;
     3883                                if(isdebris) PhiD=FindParam(DebrisPackingFractionEnum);
     3884                                CumDailyMelt=0;
     3885                                CumDailySummerMelt=0;
     3886                                debris_here=debriscover[iv];
     3887                        }
     3888
     3889                        /* Now run the debris part */
     3890
     3891                        // Climate inputs
     3892                        IssmDouble Tm;          // C air temperature
     3893                        IssmDouble In;          // Wm^-2 incoming long wave
     3894                        IssmDouble Q;           // Wm^-2 incoming short wave
     3895                        IssmDouble Um;          // ms^-1 measured wind speed
     3896                        IssmDouble Humidity;    // relative humidity
     3897                        IssmDouble P;           // precip
     3898
     3899                        // other parameters
     3900                        IssmDouble Qh=0.006;   // kg m^-3      saturated humidity level // not used
     3901                        IssmDouble Qm=0.8*Qh;  // kg m^-3      measured humiditiy level // not used
     3902                        IssmDouble Rhoaa=1.22; // kgm^-3       air densitiy
     3903                        IssmDouble K=0.585;    // Wm^-1K^-1    thermal conductivity          0.585
     3904                        IssmDouble Xr=0.01;    // ms^-1        surface roughness             0.01
     3905                        IssmDouble Ustar=0.16; // ms^-1        friction velocity             0.16
     3906                        IssmDouble Ca=1000;    // jkg^-1K^-1   specific heat capacity of air
     3907                        IssmDouble Lv=2.50E+06;// jkg^-1K^-1   latent heat of evaporation
     3908                        IssmDouble Eps=0.95;   //              thermal emissivity
     3909                        IssmDouble Sigma=5.67E-08;// Wm^-2K^-4    Stefan Boltzmann constant
     3910                        IssmDouble Gamma=180.;    // m^-1         wind speed attenuation        234
     3911               
     3912                        // Calculate effective albedo
     3913                        IssmDouble Alphaeff,Alphaeff_cleanice;
     3914                        IssmDouble mean_ela,delta=2000;
     3915                       
     3916                        // compute cleanice albedo based on previous SMB distribution
     3917                        //if(step==1){
     3918                                mean_ela=3000; //FIXME
     3919                        //}else{
     3920                        //        mean_ela=FindParam(SmbMeanElaEnum);
     3921                        //}
     3922                        Alphaeff_cleanice=icealbedo+(snowalbedo-icealbedo)*(1+tanh(PI*(surface[iv]-mean_ela)/delta))/2;
     3923                        Alphaeff=Alphaeff_cleanice; // will be updated below
     3924
     3925                       
     3926                        accu[iv]=0.;
     3927                        for (int iday=0;iday<365;iday++) {
     3928
     3929                                Tm=temperature[iv*365+iday]-st*rlaps;//+t_ampl[iv];//+(rand()%10-5)/5;
     3930                                In=lw[iv*365+iday]-st*dlgrad+lw_ampl[iv];
     3931                                Q=sw[iv*365+iday]+st*dsgrad+sw_ampl[iv];
     3932                                Humidity=humidity[iv*365+iday]-st*humiditygrad+humidity_ampl[iv];
     3933                                Um=wind[iv*365+iday]-st*windspeedgrad+wind_ampl[iv];
     3934                                P=(qlaps*st*precip[iv*365+iday]+precip[iv*365+iday]+p_ampl[iv])*sconv/365.; // convert precip from w.e. -> i.e
     3935
     3936                                /*Partition of precip in solid and liquid parts */
     3937                                IssmDouble temp_plus=1;
     3938                                IssmDouble temp_minus=-1.;
     3939                                IssmDouble frac_solid;
     3940                                if(Tm>=temp_plus){
     3941                                        frac_solid=0;
     3942                                }else if(Tm<=temp_minus){
     3943                                        frac_solid=1;
     3944                                }else{
     3945                                        frac_solid=1*(1-cos(PI*(temp_plus-Tm)/(temp_plus-temp_minus)))/2;
     3946                                }
     3947
     3948                                /*Get yearly temperatures and accumulation */
     3949                                yearlytemperatures[iv]=yearlytemperatures[iv]+((temperature[iv*365+iday]-rlaps*st+Tf+t_ampl[iv]))/365; // Has to be in Kelvin
     3950                                accu[iv]=accu[iv]+P*frac_solid;
     3951                                if(yearlytemperatures[iv]>Tf) yearlytemperatures[iv]=Tf;
     3952
     3953                                CleanIceDailyMelt=((In-(Eps*Sigma*(Tf*Tf*Tf*Tf))+
     3954                                        Q*(1.-Alphaeff)+
     3955                                        (Rhoaa*Ca*Ustar*Ustar)/(Um-Ustar*(2.-(exp(Gamma*Xr))))*Tm)/((1-PhiD)*rho_ice*Lm)/(1.+
     3956                                        ((Rhoaa*Ca*Ustar*Ustar)/(Um-Ustar*(2.-(exp(Gamma*Xr))))+4.*Eps*Sigma*(Tf*Tf*Tf))/
     3957                                        K*debris)-(Lv*Ustar*Ustar*((Humidity))*(exp(-Gamma*Xr)))/((1.-PhiD)*
     3958                                        rho_ice*Lm*Ustar)/(((Um
     3959                                        -2.*Ustar)*exp(-Gamma*Xr))/Ustar+exp(Gamma*debris)));
     3960                                if(CleanIceDailyMelt<0) CleanIceDailyMelt=0.;
     3961                                DailyMelt=CleanIceDailyMelt;
     3962
     3963                                if(ismb==1){
     3964
     3965                                        //snowheight[iv]=snowheight[iv]+(P-CleanIceDailyMelt*yts/365);
     3966                                        IssmDouble sn_prev;
     3967                                        sn_prev=snowheight[iv];
     3968                                        snowheight[iv]=sn_prev+(-CleanIceDailyMelt*yts/365);//P
     3969                                       
     3970                                        if(snowheight[iv]<=0) snowheight[iv]=0.;
     3971                                        if(snowheight[iv]<=0.0001){
     3972                                                p=debris_here*PhiD/(2*0.2*0.01); //Eq. 51 from Evatt et al 2015 without source term g*t
     3973                                                if(p>1.) p=1.;
     3974                                                if(p>=0.999){
     3975                                                        Alphaeff=debrisalbedo;
     3976                                                } else {
     3977                                                        Alphaeff=Alphaeff_cleanice+p*(debrisalbedo-Alphaeff_cleanice);
     3978                                                }
     3979                                                debris=debris_here;
     3980                                                DailyMelt=((In-(Eps*Sigma*(Tf*Tf*Tf*Tf))+
     3981                                                        Q*(1.-Alphaeff)+
     3982                                                        (Rhoaa*Ca*Ustar*Ustar)/(Um-Ustar*(2.-(exp(Gamma*Xr))))*Tm)/((1-PhiD)*rho_ice*Lm)/(1.+
     3983                                                        ((Rhoaa*Ca*Ustar*Ustar)/(Um-Ustar*(2.-(exp(Gamma*Xr))))+4.*Eps*Sigma*(Tf*Tf*Tf))/
     3984                                                        K*debris)-(Lv*Ustar*Ustar*((Humidity))*(exp(-Gamma*Xr)))/((1.-PhiD)*
     3985                                                        rho_ice*Lm*Ustar)/(((Um-2.*Ustar)*exp(-Gamma*Xr))/Ustar+exp(Gamma*debris)));
     3986                                                if(DailyMelt<0) DailyMelt=0.;
     3987                                                MeanSummerAlbedo=MeanSummerAlbedo+Alphaeff;
     3988                                                CumDailySummerMelt=CumDailySummerMelt+DailyMelt/365;
     3989                                        }
     3990                                }
     3991                                CumDailyMelt=CumDailyMelt+DailyMelt/365;
     3992                        }
     3993                        MeanAlbedo=MeanAlbedo+Alphaeff;
     3994                        if(ismb==0) CleanIceMelt=CumDailyMelt;
     3995                }
     3996
     3997                if(iscryokarst){
     3998                        if(taud>=taud_plus){
     3999                                lambda=0;
     4000                        }else if(taud>=taud_minus & taud<taud_plus){
     4001                                lambda=0.1*(1-cos(PI*(taud_plus-taud)/(taud_plus-taud_minus)))/2;
     4002                        }else if(taud<taud_minus){
     4003                                lambda=0.1;
     4004                        }
     4005                }
     4006
     4007                // update values
     4008                melt[iv]=CumDailyMelt; // is already in m/s
     4009                accu[iv]=accu[iv]/yts;
     4010                if(isAnderson){
     4011                        smb[iv]=(accu[iv]-melt[iv])*D0/(D0+debris_here);
     4012                        if(iscryokarst){
     4013                                smb[iv]=lambda*(accu[iv]-melt[iv])+(1-lambda)*(accu[iv]-melt[iv])*D0/(D0+debris_here);
     4014                        }else{
     4015                                smb[iv]=(accu[iv]-melt[iv])*D0/(D0+debris_here);
     4016                        }
     4017                }else{
     4018                        if(iscryokarst){
     4019                                smb[iv]=lambda*(accu[iv]-CleanIceMelt)+(1-lambda)*(accu[iv]-melt[iv]);
     4020                        }else{
     4021                                smb[iv]=(accu[iv]-melt[iv]);
     4022                        }
     4023                }
     4024                albedo[iv]=MeanAlbedo;
     4025                summeralbedo[iv]=MeanSummerAlbedo;
     4026                summermelt[iv]=CumDailySummerMelt;
     4027        }
     4028
     4029        this->AddInput(SmbMassBalanceEnum,smb,P1Enum);
     4030        this->AddInput(SmbAccumulationEnum,accu,P1Enum);
     4031        this->AddInput(SmbMeltEnum,melt,P1Enum);
     4032        this->AddInput(SmbSummerMeltEnum,summermelt,P1Enum);
     4033        this->AddInput(SmbSnowheightEnum,snowheight,P1Enum);
     4034        this->AddInput(SmbAlbedoEnum,albedo,P1Enum);
     4035        this->AddInput(SmbSummerAlbedoEnum,summeralbedo,P1Enum);
     4036        this->AddInput(TemperaturePDDEnum,yearlytemperatures,P1Enum); // TemperaturePDD is wrong here, but don't want to create new Enum ...
     4037
     4038        /*clean-up*/
     4039        xDelete<IssmDouble>(temperature);
     4040        xDelete<IssmDouble>(precip);
     4041        xDelete<IssmDouble>(lw);
     4042        xDelete<IssmDouble>(sw);
     4043        xDelete<IssmDouble>(wind);
     4044        xDelete<IssmDouble>(humidity);
     4045        xDelete<IssmDouble>(smb);
     4046        xDelete<IssmDouble>(surface);
     4047        xDelete<IssmDouble>(melt);
     4048        xDelete<IssmDouble>(summermelt);
     4049        xDelete<IssmDouble>(albedo);
     4050        xDelete<IssmDouble>(summeralbedo);
     4051        xDelete<IssmDouble>(accu);
     4052        xDelete<IssmDouble>(yearlytemperatures);
     4053        xDelete<IssmDouble>(s0t);
     4054        xDelete<IssmDouble>(snowheight);
     4055        xDelete<IssmDouble>(debriscover);
     4056        xDelete<IssmDouble>(t_ampl);
     4057        xDelete<IssmDouble>(p_ampl);
     4058        xDelete<IssmDouble>(lw_ampl);
     4059        xDelete<IssmDouble>(sw_ampl);
     4060        xDelete<IssmDouble>(humidity_ampl);
     4061        xDelete<IssmDouble>(wind_ampl);
     4062        xDelete<IssmDouble>(slopex);
     4063        xDelete<IssmDouble>(slopey);
     4064        xDelete<IssmDouble>(icethickness);
     4065}
     4066/*}}}*/
     4067
     4068
     4069
    37314070void       Element::ResultInterpolation(int* pinterpolation,int* pnodesperelement,int* parray_size, int output_enum){/*{{{*/
    37324071

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

    r27852 r27856  
    177177                void               PositiveDegreeDay(IssmDouble* pdds,IssmDouble* pds,IssmDouble signorm,bool ismungsm,bool issetpddfac);
    178178                void               PositiveDegreeDaySicopolis(bool isfirnwarming);
     179                void               SmbDebrisEvatt();
    179180                void               RignotMeltParameterization();
    180181                void               ResultInterpolation(int* pinterpolation,int*nodesperelement,int* parray_size, int output_enum);

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

    r27852 r27856  
    489489                        parameters->AddObject(iomodel->CopyConstantObject("md.smb.ismethod",SmbSemicMethodEnum));
    490490                        break;
    491                 case SMBdebrisMLEnum:
    492                         break;
     491                case SMBdebrisEvattEnum:
     492                        parameters->AddObject(iomodel->CopyConstantObject("md.smb.qlaps",SmbDesfacEnum));
     493                        parameters->AddObject(iomodel->CopyConstantObject("md.smb.rlaps",SmbRlapsEnum));
     494                        parameters->AddObject(iomodel->CopyConstantObject("md.smb.dsgrad",SmbSWgradEnum));
     495                        parameters->AddObject(iomodel->CopyConstantObject("md.smb.dlgrad",SmbLWgradEnum));
     496                        parameters->AddObject(iomodel->CopyConstantObject("md.smb.windspeedgrad",SmbWindspeedgradEnum));
     497                        parameters->AddObject(iomodel->CopyConstantObject("md.smb.humiditygrad",SmbHumiditygradEnum));
     498                        parameters->AddObject(iomodel->CopyConstantObject("md.smb.icealbedo",SmbIcealbedoEnum));
     499                        parameters->AddObject(iomodel->CopyConstantObject("md.smb.snowalbedo",SmbSnowalbedoEnum));
     500                        parameters->AddObject(iomodel->CopyConstantObject("md.smb.debrisalbedo",SmbDebrisalbedoEnum));
     501                        parameters->AddObject(iomodel->CopyConstantObject("md.smb.isAnderson",SmbDebrisIsAndersonEnum));
     502                        parameters->AddObject(iomodel->CopyConstantObject("md.smb.iscryokarst",SmbDebrisIsCryokarstEnum));
     503                        parameters->AddObject(iomodel->CopyConstantObject("md.smb.AndersonD0",SmbDebrisAndersonD0Enum));
     504                        break;
    493505                default:
    494506                        _error_("Surface mass balance model "<<EnumToStringx(smb_model)<<" not supported yet");

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

    r27852 r27856  
    504504
    505505}/*}}}*/
    506 void SmbDebrisMLx(FemModel* femmodel){/*{{{*/
    507 
    508         //      The function is based on:
    509         //      Evatt GW, Abrahams ID, Heil M, Mayer C, Kingslake J, Mitchell SL, et al. Glacial melt under a porous debris layer. Journal of Glaciology 61 (2015) 825–836, doi:10.3189/2
    510         //      Constants/Values are taken from Mayer, Licciulli (2021): https://www.frontiersin.org/articles/10.3389/feart.2021.710276/full#B7
    511         //      function taken from https://github.com/carlolic/DebrisExp/blob/main/USFs/USF_DebrisCoverage.f90
    512 
    513         /*Intermediaries*/
    514         // altitude gradients of the crucial parameters (radiation from Marty et al., TaAClimat; 2002)
    515         IssmDouble LW=2.9;          // W/m^2 /100m                       2.9
    516         IssmDouble SW=1.3;          // W/m^2 /100m                       1.3
    517         IssmDouble HumidityG=0;     // % /100m         rough estimate
    518         IssmDouble AirTemp=0.7;     // C /100m
    519         IssmDouble WindSpeed=0.02;  // m/s /100m       rough estimate    0.2
    520 
    521         // accumulation follows a linear increase above the ELA up to a plateau
    522         IssmDouble AccG=0.1;                    // m w.e. /100m
    523         IssmDouble AccMax=1.;                    // m w.e.
    524         IssmDouble ReferenceElevation;
    525         IssmDouble AblationDays=120.;            //
    526 
    527         IssmDouble In=100.;                 // Wm^-2        incoming long wave
    528         IssmDouble Q=500.;                  // Wm^-2        incoming short wave
    529         IssmDouble K=0.585;                // Wm^-1K^-1    thermal conductivity          0.585
    530         IssmDouble Qm=0.0012;              // kg m^-3      measured humiditiy level
    531         IssmDouble Qh=0.006 ;              // kg m^-3      saturated humidity level
    532         IssmDouble Tm=2.;                   // C            air temperature
    533         IssmDouble Rhoaa=1.22;             // kgm^-3       air densitiy
    534         IssmDouble Um=1.5;                 // ms^-1        measured wind speed
    535         IssmDouble Xm=1.5;                 // ms^-1        measurement height
    536         IssmDouble Xr=0.01;                // ms^-1        surface roughness             0.01
    537         IssmDouble Alphad=0.07;            //              debris albedo                 0.07
    538         IssmDouble Alphai=0.4;             //              ice ablbedo
    539         IssmDouble Alphaeff;
    540         IssmDouble Ustar=0.16;             // ms^-1        friction velocity             0.16
    541         IssmDouble Ca=1000.;                // jkg^-1K^-1   specific heat capacity of air
    542         IssmDouble Lm;//=3.34E+05;            // jkg^-1K^-1   latent heat of ice melt
    543         IssmDouble Lv=2.50E+06;            // jkg^-1K^-1   latent heat of evaporation
    544         IssmDouble Tf=273.;                 // K            water freeezing temperature
    545         IssmDouble Eps=0.95;               //              thermal emissivity
    546         IssmDouble Rhoi=900.;               // kgm^-3       ice density
    547         IssmDouble Sigma=5.67E-08;         // Wm^-2K^-4    Stefan Boltzmann constant
    548         IssmDouble Kstar=0.4;              //              von kármán constant
    549         IssmDouble Gamma=180.;              // m^-1         wind speed attenuation        234
    550         IssmDouble PhiD;//=0.005;              //              debris packing fraction       0.01
    551         IssmDouble Humidity=0.2;           //              relative humidity
    552 
    553         IssmDouble smb,yts,z,debris;
    554         IssmDouble MassBalanceCmDayDebris,MassBalanceMYearDebris;
    555         bool isdebris;
    556         int domaintype;
    557         femmodel->parameters->FindParam(&isdebris,TransientIsdebrisEnum);
    558 
    559         /*Get material parameters and constants */
    560         //femmodel->parameters->FindParam(&Rhoi,MaterialsRhoIceEnum); // Note Carlo's model used as  benchmark was run with different densities for debris and FS
    561         femmodel->parameters->FindParam(&Lm,MaterialsLatentheatEnum);
    562         femmodel->parameters->FindParam(&yts,ConstantsYtsEnum);
    563         PhiD=0.;
    564         if(isdebris) femmodel->parameters->FindParam(&PhiD,DebrisPackingFractionEnum);
    565 
    566         /* Loop over all the elements of this partition */
    567         for(Object* & object : femmodel->elements->objects){
    568                 Element* element=xDynamicCast<Element*>(object);
    569 
    570                 /* Allocate all arrays */
    571                 int         numvertices=element->GetNumberOfVertices();
    572                 IssmDouble* surfacelist=xNew<IssmDouble>(numvertices);
    573                 IssmDouble* smb=xNew<IssmDouble>(numvertices);
    574                 IssmDouble* debriscover=xNew<IssmDouble>(numvertices);
    575                 element->GetInputListOnVertices(surfacelist,SurfaceEnum);
    576 
    577                 /* Get inputs */
    578                 element->GetInputListOnVertices(debriscover,DebrisThicknessEnum);
    579                 element->FindParam(&domaintype,DomainTypeEnum);         
    580 
    581                 /*Loop over all vertices of element and calculate SMB as function of Debris Cover and z */
    582                 for(int v=0;v<numvertices;v++){
    583 
    584                         /*Get vertex elevation */
    585                         z=surfacelist[v];
    586 
    587                         /*Get top element*/
    588                         //if(domaintype==Domain3DEnum){
    589 
    590                         //}else{
    591                         //      Alphaeff=Alphad;
    592                         //      ReferenceElevation=2200.;     // m M&L                         
    593                         //}
    594 
    595                         /* compute smb */
    596                         for (int ismb=0;ismb<2;ismb++){
    597                                 if(ismb==0){
    598                                         // calc a reference smb to identify accum and melt region; debris only develops in ablation area
    599                                         debris=0.;
    600                                         PhiD=0.;
    601                                 }else{
    602                                         // only in the meltregime debris develops
    603                                         if(-MassBalanceCmDayDebris<1e-14) debris=debriscover[v];
    604                                 }
    605                                 if(debris<=0.) debris=0.;
    606                                 IssmDouble dk=1e-5; // TODO make Alphad and Alphai a user input
    607                                 IssmDouble n=debris/dk;
    608                                 IssmDouble nmax=1000;
    609                                 IssmDouble Alphaeff;
    610                                 if(n>nmax){
    611                                         Alphaeff=Alphad;
    612                                 } else {
    613                                         Alphaeff=Alphai+n*(Alphad-Alphai)/nmax;
    614                                 }
    615                                 ReferenceElevation=3200.;     // m HEF
    616 
    617 
    618                                 Alphaeff=Alphad;
    619                                 ReferenceElevation=2200.;     // m M&L 
    620 
    621                                 MassBalanceCmDayDebris=(((In-(z-ReferenceElevation)*LW/100.)-(Eps*Sigma*(Tf*Tf*Tf*Tf))+
    622                                                         (Q+(z-ReferenceElevation)*SW/100.)*(1.-Alphaeff)+
    623                                                         (Rhoaa*Ca*Ustar*Ustar)/((Um-(z-ReferenceElevation)*
    624                                                                         WindSpeed/100.)-Ustar*(2.-(exp(Gamma*Xr))))*(Tm-(z-
    625                                                                                 ReferenceElevation)*AirTemp/100.))/((1-PhiD)*Rhoi*Lm)/(1.+
    626                                                                         ((Rhoaa*Ca*Ustar*Ustar)/((Um-(z-ReferenceElevation)*
    627                                                                                         WindSpeed/100.)-Ustar*(2.-(exp(Gamma*Xr))))+4.*Eps*Sigma*(Tf*Tf*Tf))/
    628                                                                         K*debris)-(Lv*Ustar*Ustar*(Qh-(Qh*(Humidity-(z-
    629                                                                                                                 ReferenceElevation)*HumidityG/100.)))*(exp(-Gamma*Xr)))/((1.-PhiD)*
    630                                                                                         Rhoi*Lm*Ustar)/((((Um-(z-ReferenceElevation)*WindSpeed/100.)
    631                                     -2.*Ustar)*exp(-Gamma*Xr))/Ustar+exp(Gamma*debris)))*100.*24.*60.*60.;
    632                         }
    633 
    634                         /* account form ablation days, and convert to m/s */
    635                         MassBalanceMYearDebris=-MassBalanceCmDayDebris/100.*AblationDays/yts;
    636 
    637                         /*Update array accordingly*/
    638                         smb[v]=MassBalanceMYearDebris;
    639                 }
    640 
    641                 /*Add input to element and Free memory*/
    642                 element->AddInput(SmbMassBalanceEnum,smb,P1Enum);
    643                 xDelete<IssmDouble>(surfacelist);
    644                 xDelete<IssmDouble>(smb);
    645                 xDelete<IssmDouble>(debriscover);
    646         }
     506void SmbDebrisEvattx(FemModel* femmodel){/*{{{*/
     507        for(Object* & object : femmodel->elements->objects){
     508                Element* element=xDynamicCast<Element*>(object);
     509                element->SmbDebrisEvatt();
     510        }
    647511}/*}}}*/
    648512void SmbGradientsComponentsx(FemModel* femmodel){/*{{{*/

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

    r27852 r27856  
    2323void SmbMeltComponentsx(FemModel* femmodel);
    2424void SmbGradientsComponentsx(FemModel* femmodel);
    25 void SmbDebrisMLx(FemModel* femmodel);
     25void SmbDebrisEvattx(FemModel* femmodel);
    2626/* SEMIC: */
    2727void SmbSemicx(FemModel* femmodel, int ismethod);

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

    r27852 r27856  
    539539syn keyword cConstant SmbARMAmaOrderEnum
    540540syn keyword cConstant SmbAveragingEnum
     541syn keyword cConstant SmbDebrisalbedoEnum
     542syn keyword cConstant SmbIcealbedoEnum
     543syn keyword cConstant SmbSnowalbedoEnum
     544syn keyword cConstant SmbDebrisIsAndersonEnum
     545syn keyword cConstant SmbDebrisIsCryokarstEnum
     546syn keyword cConstant SmbDebrisAndersonD0Enum
    541547syn keyword cConstant SmbDesfacEnum
    542548syn keyword cConstant SmbDesfacElevEnum
    … …  
    552558syn keyword cConstant SmbEIdxEnum
    553559syn keyword cConstant SmbFEnum
     560syn keyword cConstant SmbHumiditygradEnum
    554561syn keyword cConstant SmbInitDensityScalingEnum
    555562syn keyword cConstant SmbIsaccumulationEnum
    … …  
    572579syn keyword cConstant SmbKEnum
    573580syn keyword cConstant SmbLapseRatesEnum
     581syn keyword cConstant SmbLWgradEnum
    574582syn keyword cConstant SmbNumBasinsEnum
    575583syn keyword cConstant SmbNumBreaksEnum
    … …  
    604612syn keyword cConstant SmbStepsPerStepEnum
    605613syn keyword cConstant SmbSwIdxEnum
     614syn keyword cConstant SmbSWgradEnum
    606615syn keyword cConstant SmbT0dryEnum
    607616syn keyword cConstant SmbT0wetEnum
    … …  
    612621syn keyword cConstant SmbTemperaturesReconstructedYearsEnum
    613622syn keyword cConstant SmbPrecipitationsReconstructedYearsEnum
     623syn keyword cConstant SmbWindspeedgradEnum
    614624syn keyword cConstant SmoothThicknessMultiplierEnum
    615625syn keyword cConstant SolutionTypeEnum
    … …  
    11071117syn keyword cConstant SmbMeltEnum
    11081118syn keyword cConstant SmbMonthlytemperaturesEnum
     1119syn keyword cConstant SmbMonthlydsradiationEnum
     1120syn keyword cConstant SmbMonthlydlradiationEnum
     1121syn keyword cConstant SmbMonthlywindspeedEnum
     1122syn keyword cConstant SmbMonthlyairhumidityEnum
    11091123syn keyword cConstant SmbMSurfEnum
    11101124syn keyword cConstant SmbNetLWEnum
    … …  
    11161130syn keyword cConstant SmbPrecipitationEnum
    11171131syn keyword cConstant SmbPrecipitationsAnomalyEnum
     1132syn keyword cConstant SmbDsradiationAnomalyEnum
     1133syn keyword cConstant SmbDlradiationAnomalyEnum
     1134syn keyword cConstant SmbWindspeedAnomalyEnum
     1135syn keyword cConstant SmbAirhumidityAnomalyEnum
    11181136syn keyword cConstant SmbPrecipitationsLgmEnum
    11191137syn keyword cConstant SmbPrecipitationsPresentdayEnum
    … …  
    11351153syn keyword cConstant SmbSmbrefEnum
    11361154syn keyword cConstant SmbSzaValueEnum
     1155syn keyword cConstant SmbSummerMeltEnum
     1156syn keyword cConstant SmbSummerAlbedoEnum
     1157syn keyword cConstant SmbSnowheightEnum
    11371158syn keyword cConstant SmbTEnum
    11381159syn keyword cConstant SmbTaEnum
    … …  
    16541675syn keyword cConstant SMBarmaEnum
    16551676syn keyword cConstant SMBcomponentsEnum
    1656 syn keyword cConstant SMBdebrisMLEnum
     1677syn keyword cConstant SMBdebrisEvattEnum
    16571678syn keyword cConstant SMBd18opddEnum
    16581679syn keyword cConstant SMBforcingEnum
    … …  
    17801801syn keyword cType Cfsurfacesquaretransient
    17811802syn keyword cType Channel
     1803syn keyword cType classes
    17821804syn keyword cType Constraint
    17831805syn keyword cType Constraints
    … …  
    17871809syn keyword cType ControlParam
    17881810syn keyword cType Covertree
     1811syn keyword cType DatasetInput
    17891812syn keyword cType DataSetParam
    1790 syn keyword cType DatasetInput
    17911813syn keyword cType Definition
    17921814syn keyword cType DependentObject
    … …  
    18011823syn keyword cType ElementInput
    18021824syn keyword cType ElementMatrix
     1825syn keyword cType Elements
    18031826syn keyword cType ElementVector
    1804 syn keyword cType Elements
    18051827syn keyword cType ExponentialVariogram
    18061828syn keyword cType ExternalResult
    … …  
    18091831syn keyword cType Friction
    18101832syn keyword cType Gauss
     1833syn keyword cType GaussianVariogram
     1834syn keyword cType gaussobjects
    18111835syn keyword cType GaussPenta
    18121836syn keyword cType GaussSeg
    18131837syn keyword cType GaussTetra
    18141838syn keyword cType GaussTria
    1815 syn keyword cType GaussianVariogram
    18161839syn keyword cType GenericExternalResult
    18171840syn keyword cType GenericOption
    … …  
    18301853syn keyword cType IssmDirectApplicInterface
    18311854syn keyword cType IssmParallelDirectApplicInterface
     1855syn keyword cType krigingobjects
    18321856syn keyword cType Load
    18331857syn keyword cType Loads
    … …  
    18401864syn keyword cType Matice
    18411865syn keyword cType Matlitho
     1866syn keyword cType matrixobjects
    18421867syn keyword cType MatrixParam
    18431868syn keyword cType Misfit
    … …  
    18521877syn keyword cType Observations
    18531878syn keyword cType Option
     1879syn keyword cType Options
    18541880syn keyword cType OptionUtilities
    1855 syn keyword cType Options
    18561881syn keyword cType Param
    18571882syn keyword cType Parameters
    … …  
    18671892syn keyword cType Regionaloutput
    18681893syn keyword cType Results
     1894syn keyword cType Riftfront
    18691895syn keyword cType RiftStruct
    1870 syn keyword cType Riftfront
    18711896syn keyword cType SealevelGeometry
    18721897syn keyword cType Seg
    18731898syn keyword cType SegInput
     1899syn keyword cType Segment
    18741900syn keyword cType SegRef
    1875 syn keyword cType Segment
    18761901syn keyword cType SpcDynamic
    18771902syn keyword cType SpcStatic
    … …  
    18921917syn keyword cType Vertex
    18931918syn keyword cType Vertices
    1894 syn keyword cType classes
    1895 syn keyword cType gaussobjects
    1896 syn keyword cType krigingobjects
    1897 syn keyword cType matrixobjects
    18981919syn keyword cType AdjointBalancethickness2Analysis
    18991920syn keyword cType AdjointBalancethicknessAnalysis

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

    r27852 r27856  
    533533   SmbARMAmaOrderEnum,
    534534        SmbAveragingEnum,
     535        SmbDebrisalbedoEnum,
     536        SmbIcealbedoEnum,
     537        SmbSnowalbedoEnum,
     538        SmbDebrisIsAndersonEnum,
     539        SmbDebrisIsCryokarstEnum,
     540        SmbDebrisAndersonD0Enum,
    535541        SmbDesfacEnum,
    536542        SmbDesfacElevEnum,
    … …  
    546552        SmbEIdxEnum,
    547553        SmbFEnum,
     554        SmbHumiditygradEnum,
    548555        SmbInitDensityScalingEnum,
    549556        SmbIsaccumulationEnum,
    … …  
    566573        SmbKEnum,
    567574   SmbLapseRatesEnum,
     575        SmbLWgradEnum,
    568576        SmbNumBasinsEnum,
    569577        SmbNumBreaksEnum,
    … …  
    598606        SmbStepsPerStepEnum,
    599607        SmbSwIdxEnum,
     608        SmbSWgradEnum,
    600609        SmbT0dryEnum,
    601610        SmbT0wetEnum,
    … …  
    606615        SmbTemperaturesReconstructedYearsEnum,
    607616        SmbPrecipitationsReconstructedYearsEnum,
     617        SmbWindspeedgradEnum,
    608618        SmoothThicknessMultiplierEnum,
    609619        SolutionTypeEnum,
    … …  
    11041114        SmbMInitnum,
    11051115        SmbMonthlytemperaturesEnum,
     1116        SmbMonthlydsradiationEnum,
     1117        SmbMonthlydlradiationEnum,
     1118        SmbMonthlywindspeedEnum,
     1119        SmbMonthlyairhumidityEnum,
    11061120        SmbMSurfEnum,
    11071121        SmbNetLWEnum,
    … …  
    11131127        SmbPrecipitationEnum,
    11141128        SmbPrecipitationsAnomalyEnum,
     1129        SmbDsradiationAnomalyEnum,
     1130        SmbDlradiationAnomalyEnum,
     1131        SmbWindspeedAnomalyEnum,
     1132        SmbAirhumidityAnomalyEnum,
    11151133        SmbPrecipitationsLgmEnum,
    11161134        SmbPrecipitationsPresentdayEnum,
    … …  
    11321150        SmbSmbrefEnum,
    11331151        SmbSzaValueEnum,
     1152        SmbSummerMeltEnum,
     1153        SmbSummerAlbedoEnum,
     1154        SmbSnowheightEnum,
    11341155        SmbTEnum,
    11351156        SmbTaEnum,
    … …  
    16531674        SMBarmaEnum,
    16541675        SMBcomponentsEnum,
    1655         SMBdebrisMLEnum,
     1676        SMBdebrisEvattEnum,
    16561677        SMBd18opddEnum,
    16571678        SMBforcingEnum,

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

    r27852 r27856  
    541541                case SmbARMAmaOrderEnum : return "SmbARMAmaOrder";
    542542                case SmbAveragingEnum : return "SmbAveraging";
     543                case SmbDebrisalbedoEnum : return "SmbDebrisalbedo";
     544                case SmbIcealbedoEnum : return "SmbIcealbedo";
     545                case SmbSnowalbedoEnum : return "SmbSnowalbedo";
     546                case SmbDebrisIsAndersonEnum : return "SmbDebrisIsAnderson";
     547                case SmbDebrisIsCryokarstEnum : return "SmbDebrisIsCryokarst";
     548                case SmbDebrisAndersonD0Enum : return "SmbDebrisAndersonD0";
    543549                case SmbDesfacEnum : return "SmbDesfac";
    544550                case SmbDesfacElevEnum : return "SmbDesfacElev";
    … …  
    554560                case SmbEIdxEnum : return "SmbEIdx";
    555561                case SmbFEnum : return "SmbF";
     562                case SmbHumiditygradEnum : return "SmbHumiditygrad";
    556563                case SmbInitDensityScalingEnum : return "SmbInitDensityScaling";
    557564                case SmbIsaccumulationEnum : return "SmbIsaccumulation";
    … …  
    574581                case SmbKEnum : return "SmbK";
    575582                case SmbLapseRatesEnum : return "SmbLapseRates";
     583                case SmbLWgradEnum : return "SmbLWgrad";
    576584                case SmbNumBasinsEnum : return "SmbNumBasins";
    577585                case SmbNumBreaksEnum : return "SmbNumBreaks";
    … …  
    606614                case SmbStepsPerStepEnum : return "SmbStepsPerStep";
    607615                case SmbSwIdxEnum : return "SmbSwIdx";
     616                case SmbSWgradEnum : return "SmbSWgrad";
    608617                case SmbT0dryEnum : return "SmbT0dry";
    609618                case SmbT0wetEnum : return "SmbT0wet";
    … …  
    614623                case SmbTemperaturesReconstructedYearsEnum : return "SmbTemperaturesReconstructedYears";
    615624                case SmbPrecipitationsReconstructedYearsEnum : return "SmbPrecipitationsReconstructedYears";
     625                case SmbWindspeedgradEnum : return "SmbWindspeedgrad";
    616626                case SmoothThicknessMultiplierEnum : return "SmoothThicknessMultiplier";
    617627                case SolutionTypeEnum : return "SolutionType";
    … …  
    11091119                case SmbMeltEnum : return "SmbMelt";
    11101120                case SmbMonthlytemperaturesEnum : return "SmbMonthlytemperatures";
     1121                case SmbMonthlydsradiationEnum : return "SmbMonthlydsradiation";
     1122                case SmbMonthlydlradiationEnum : return "SmbMonthlydlradiation";
     1123                case SmbMonthlywindspeedEnum : return "SmbMonthlywindspeed";
     1124                case SmbMonthlyairhumidityEnum : return "SmbMonthlyairhumidity";
    11111125                case SmbMSurfEnum : return "SmbMSurf";
    11121126                case SmbNetLWEnum : return "SmbNetLW";
    … …  
    11181132                case SmbPrecipitationEnum : return "SmbPrecipitation";
    11191133                case SmbPrecipitationsAnomalyEnum : return "SmbPrecipitationsAnomaly";
     1134                case SmbDsradiationAnomalyEnum : return "SmbDsradiationAnomaly";
     1135                case SmbDlradiationAnomalyEnum : return "SmbDlradiationAnomaly";
     1136                case SmbWindspeedAnomalyEnum : return "SmbWindspeedAnomaly";
     1137                case SmbAirhumidityAnomalyEnum : return "SmbAirhumidityAnomaly";
    11201138                case SmbPrecipitationsLgmEnum : return "SmbPrecipitationsLgm";
    11211139                case SmbPrecipitationsPresentdayEnum : return "SmbPrecipitationsPresentday";
    … …  
    11371155                case SmbSmbrefEnum : return "SmbSmbref";
    11381156                case SmbSzaValueEnum : return "SmbSzaValue";
     1157                case SmbSummerMeltEnum : return "SmbSummerMelt";
     1158                case SmbSummerAlbedoEnum : return "SmbSummerAlbedo";
     1159                case SmbSnowheightEnum : return "SmbSnowheight";
    11391160                case SmbTEnum : return "SmbT";
    11401161                case SmbTaEnum : return "SmbTa";
    … …  
    16561677                case SMBarmaEnum : return "SMBarma";
    16571678                case SMBcomponentsEnum : return "SMBcomponents";
    1658                 case SMBdebrisMLEnum : return "SMBdebrisML";
     1679                case SMBdebrisEvattEnum : return "SMBdebrisEvatt";
    16591680                case SMBd18opddEnum : return "SMBd18opdd";
    16601681                case SMBforcingEnum : return "SMBforcing";

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

    r27852 r27856  
    532532syn keyword juliaConstC SmbARMAmaOrderEnum
    533533syn keyword juliaConstC SmbAveragingEnum
     534syn keyword juliaConstC SmbDebrisalbedoEnum
     535syn keyword juliaConstC SmbIcealbedoEnum
     536syn keyword juliaConstC SmbSnowalbedoEnum
     537syn keyword juliaConstC SmbDebrisIsAndersonEnum
     538syn keyword juliaConstC SmbDebrisIsCryokarstEnum
     539syn keyword juliaConstC SmbDebrisAndersonD0Enum
    534540syn keyword juliaConstC SmbDesfacEnum
    535541syn keyword juliaConstC SmbDesfacElevEnum
    … …  
    545551syn keyword juliaConstC SmbEIdxEnum
    546552syn keyword juliaConstC SmbFEnum
     553syn keyword juliaConstC SmbHumiditygradEnum
    547554syn keyword juliaConstC SmbInitDensityScalingEnum
    548555syn keyword juliaConstC SmbIsaccumulationEnum
    … …  
    565572syn keyword juliaConstC SmbKEnum
    566573syn keyword juliaConstC SmbLapseRatesEnum
     574syn keyword juliaConstC SmbLWgradEnum
    567575syn keyword juliaConstC SmbNumBasinsEnum
    568576syn keyword juliaConstC SmbNumBreaksEnum
    … …  
    597605syn keyword juliaConstC SmbStepsPerStepEnum
    598606syn keyword juliaConstC SmbSwIdxEnum
     607syn keyword juliaConstC SmbSWgradEnum
    599608syn keyword juliaConstC SmbT0dryEnum
    600609syn keyword juliaConstC SmbT0wetEnum
    … …  
    605614syn keyword juliaConstC SmbTemperaturesReconstructedYearsEnum
    606615syn keyword juliaConstC SmbPrecipitationsReconstructedYearsEnum
     616syn keyword juliaConstC SmbWindspeedgradEnum
    607617syn keyword juliaConstC SmoothThicknessMultiplierEnum
    608618syn keyword juliaConstC SolutionTypeEnum
    … …  
    11001110syn keyword juliaConstC SmbMeltEnum
    11011111syn keyword juliaConstC SmbMonthlytemperaturesEnum
     1112syn keyword juliaConstC SmbMonthlydsradiationEnum
     1113syn keyword juliaConstC SmbMonthlydlradiationEnum
     1114syn keyword juliaConstC SmbMonthlywindspeedEnum
     1115syn keyword juliaConstC SmbMonthlyairhumidityEnum
    11021116syn keyword juliaConstC SmbMSurfEnum
    11031117syn keyword juliaConstC SmbNetLWEnum
    … …  
    11091123syn keyword juliaConstC SmbPrecipitationEnum
    11101124syn keyword juliaConstC SmbPrecipitationsAnomalyEnum
     1125syn keyword juliaConstC SmbDsradiationAnomalyEnum
     1126syn keyword juliaConstC SmbDlradiationAnomalyEnum
     1127syn keyword juliaConstC SmbWindspeedAnomalyEnum
     1128syn keyword juliaConstC SmbAirhumidityAnomalyEnum
    11111129syn keyword juliaConstC SmbPrecipitationsLgmEnum
    11121130syn keyword juliaConstC SmbPrecipitationsPresentdayEnum
    … …  
    11281146syn keyword juliaConstC SmbSmbrefEnum
    11291147syn keyword juliaConstC SmbSzaValueEnum
     1148syn keyword juliaConstC SmbSummerMeltEnum
     1149syn keyword juliaConstC SmbSummerAlbedoEnum
     1150syn keyword juliaConstC SmbSnowheightEnum
    11301151syn keyword juliaConstC SmbTEnum
    11311152syn keyword juliaConstC SmbTaEnum
    … …  
    16471668syn keyword juliaConstC SMBarmaEnum
    16481669syn keyword juliaConstC SMBcomponentsEnum
    1649 syn keyword juliaConstC SMBdebrisMLEnum
     1670syn keyword juliaConstC SMBdebrisEvattEnum
    16501671syn keyword juliaConstC SMBd18opddEnum
    16511672syn keyword juliaConstC SMBforcingEnum

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

    r27852 r27856  
    553553              else if (strcmp(name,"SmbARMAmaOrder")==0) return SmbARMAmaOrderEnum;
    554554              else if (strcmp(name,"SmbAveraging")==0) return SmbAveragingEnum;
     555              else if (strcmp(name,"SmbDebrisalbedo")==0) return SmbDebrisalbedoEnum;
     556              else if (strcmp(name,"SmbIcealbedo")==0) return SmbIcealbedoEnum;
     557              else if (strcmp(name,"SmbSnowalbedo")==0) return SmbSnowalbedoEnum;
     558              else if (strcmp(name,"SmbDebrisIsAnderson")==0) return SmbDebrisIsAndersonEnum;
     559              else if (strcmp(name,"SmbDebrisIsCryokarst")==0) return SmbDebrisIsCryokarstEnum;
     560              else if (strcmp(name,"SmbDebrisAndersonD0")==0) return SmbDebrisAndersonD0Enum;
    555561              else if (strcmp(name,"SmbDesfac")==0) return SmbDesfacEnum;
    556562              else if (strcmp(name,"SmbDesfacElev")==0) return SmbDesfacElevEnum;
    … …  
    566572              else if (strcmp(name,"SmbEIdx")==0) return SmbEIdxEnum;
    567573              else if (strcmp(name,"SmbF")==0) return SmbFEnum;
     574              else if (strcmp(name,"SmbHumiditygrad")==0) return SmbHumiditygradEnum;
    568575              else if (strcmp(name,"SmbInitDensityScaling")==0) return SmbInitDensityScalingEnum;
    569576              else if (strcmp(name,"SmbIsaccumulation")==0) return SmbIsaccumulationEnum;
    … …  
    586593              else if (strcmp(name,"SmbK")==0) return SmbKEnum;
    587594              else if (strcmp(name,"SmbLapseRates")==0) return SmbLapseRatesEnum;
     595              else if (strcmp(name,"SmbLWgrad")==0) return SmbLWgradEnum;
    588596              else if (strcmp(name,"SmbNumBasins")==0) return SmbNumBasinsEnum;
    589597              else if (strcmp(name,"SmbNumBreaks")==0) return SmbNumBreaksEnum;
    … …  
    618626              else if (strcmp(name,"SmbStepsPerStep")==0) return SmbStepsPerStepEnum;
    619627              else if (strcmp(name,"SmbSwIdx")==0) return SmbSwIdxEnum;
     628              else if (strcmp(name,"SmbSWgrad")==0) return SmbSWgradEnum;
    620629              else if (strcmp(name,"SmbT0dry")==0) return SmbT0dryEnum;
    621630              else if (strcmp(name,"SmbT0wet")==0) return SmbT0wetEnum;
    622               else if (strcmp(name,"SmbTcIdx")==0) return SmbTcIdxEnum;
     631         else stage=6;
     632   }
     633   if(stage==6){
     634              if (strcmp(name,"SmbTcIdx")==0) return SmbTcIdxEnum;
    623635              else if (strcmp(name,"SmbTeThresh")==0) return SmbTeThreshEnum;
    624636              else if (strcmp(name,"SmbTdiff")==0) return SmbTdiffEnum;
    … …  
    626638              else if (strcmp(name,"SmbTemperaturesReconstructedYears")==0) return SmbTemperaturesReconstructedYearsEnum;
    627639              else if (strcmp(name,"SmbPrecipitationsReconstructedYears")==0) return SmbPrecipitationsReconstructedYearsEnum;
     640              else if (strcmp(name,"SmbWindspeedgrad")==0) return SmbWindspeedgradEnum;
    628641              else if (strcmp(name,"SmoothThicknessMultiplier")==0) return SmoothThicknessMultiplierEnum;
    629642              else if (strcmp(name,"SolutionType")==0) return SolutionTypeEnum;
    630643              else if (strcmp(name,"SteadystateMaxiter")==0) return SteadystateMaxiterEnum;
    631          else stage=6;
    632    }
    633    if(stage==6){
    634               if (strcmp(name,"SteadystateNumRequestedOutputs")==0) return SteadystateNumRequestedOutputsEnum;
     644              else if (strcmp(name,"SteadystateNumRequestedOutputs")==0) return SteadystateNumRequestedOutputsEnum;
    635645              else if (strcmp(name,"SteadystateReltol")==0) return SteadystateReltolEnum;
    636646              else if (strcmp(name,"SteadystateRequestedOutputs")==0) return SteadystateRequestedOutputsEnum;
    … …  
    742752              else if (strcmp(name,"BasalforcingsSpatialUpperwaterMeltingRate")==0) return BasalforcingsSpatialUpperwaterMeltingRateEnum;
    743753              else if (strcmp(name,"BasalforcingsIsmip6BasinId")==0) return BasalforcingsIsmip6BasinIdEnum;
    744               else if (strcmp(name,"BasalforcingsIsmip6Tf")==0) return BasalforcingsIsmip6TfEnum;
     754         else stage=7;
     755   }
     756   if(stage==7){
     757              if (strcmp(name,"BasalforcingsIsmip6Tf")==0) return BasalforcingsIsmip6TfEnum;
    745758              else if (strcmp(name,"BasalforcingsIsmip6TfShelf")==0) return BasalforcingsIsmip6TfShelfEnum;
    746759              else if (strcmp(name,"BasalforcingsIsmip6MeltAnomaly")==0) return BasalforcingsIsmip6MeltAnomalyEnum;
    … …  
    752765              else if (strcmp(name,"BasalforcingsPicoOverturningCoeff")==0) return BasalforcingsPicoOverturningCoeffEnum;
    753766              else if (strcmp(name,"BasalforcingsPicoSubShelfOceanOverturning")==0) return BasalforcingsPicoSubShelfOceanOverturningEnum;
    754          else stage=7;
    755    }
    756    if(stage==7){
    757               if (strcmp(name,"BasalforcingsPicoSubShelfOceanSalinity")==0) return BasalforcingsPicoSubShelfOceanSalinityEnum;
     767              else if (strcmp(name,"BasalforcingsPicoSubShelfOceanSalinity")==0) return BasalforcingsPicoSubShelfOceanSalinityEnum;
    758768              else if (strcmp(name,"BasalforcingsPicoSubShelfOceanTemp")==0) return BasalforcingsPicoSubShelfOceanTempEnum;
    759769              else if (strcmp(name,"BasalStressx")==0) return BasalStressxEnum;
    … …  
    865875              else if (strcmp(name,"FrictionWaterLayer")==0) return FrictionWaterLayerEnum;
    866876              else if (strcmp(name,"FrictionWaterPressure")==0) return FrictionWaterPressureEnum;
    867               else if (strcmp(name,"FrictionWaterPressureNoise")==0) return FrictionWaterPressureNoiseEnum;
     877         else stage=8;
     878   }
     879   if(stage==8){
     880              if (strcmp(name,"FrictionWaterPressureNoise")==0) return FrictionWaterPressureNoiseEnum;
    868881              else if (strcmp(name,"Frictionf")==0) return FrictionfEnum;
    869882              else if (strcmp(name,"FrontalForcingsBasinId")==0) return FrontalForcingsBasinIdEnum;
    … …  
    875888              else if (strcmp(name,"UGia")==0) return UGiaEnum;
    876889              else if (strcmp(name,"UGiaRate")==0) return UGiaRateEnum;
    877          else stage=8;
    878    }
    879    if(stage==8){
    880               if (strcmp(name,"Gradient")==0) return GradientEnum;
     890              else if (strcmp(name,"Gradient")==0) return GradientEnum;
    881891              else if (strcmp(name,"GroundinglineHeight")==0) return GroundinglineHeightEnum;
    882892              else if (strcmp(name,"HydraulicPotential")==0) return HydraulicPotentialEnum;
    … …  
    988998              else if (strcmp(name,"SealevelBarystaticMask")==0) return SealevelBarystaticMaskEnum;
    989999              else if (strcmp(name,"SealevelBarystaticIceMask")==0) return SealevelBarystaticIceMaskEnum;
    990               else if (strcmp(name,"SealevelBarystaticIceWeights")==0) return SealevelBarystaticIceWeightsEnum;
     1000         else stage=9;
     1001   }
     1002   if(stage==9){
     1003              if (strcmp(name,"SealevelBarystaticIceWeights")==0) return SealevelBarystaticIceWeightsEnum;
    9911004              else if (strcmp(name,"SealevelBarystaticIceArea")==0) return SealevelBarystaticIceAreaEnum;
    9921005              else if (strcmp(name,"SealevelBarystaticIceLatbar")==0) return SealevelBarystaticIceLatbarEnum;
    … …  
    9981011              else if (strcmp(name,"SealevelBarystaticHydroLatbar")==0) return SealevelBarystaticHydroLatbarEnum;
    9991012              else if (strcmp(name,"SealevelBarystaticHydroLongbar")==0) return SealevelBarystaticHydroLongbarEnum;
    1000          else stage=9;
    1001    }
    1002    if(stage==9){
    1003               if (strcmp(name,"SealevelBarystaticHydroLoad")==0) return SealevelBarystaticHydroLoadEnum;
     1013              else if (strcmp(name,"SealevelBarystaticHydroLoad")==0) return SealevelBarystaticHydroLoadEnum;
    10041014              else if (strcmp(name,"SealevelBarystaticBpMask")==0) return SealevelBarystaticBpMaskEnum;
    10051015              else if (strcmp(name,"SealevelBarystaticBpWeights")==0) return SealevelBarystaticBpWeightsEnum;
    … …  
    11111121              else if (strcmp(name,"SmbFAC")==0) return SmbFACEnum;
    11121122              else if (strcmp(name,"SmbGdn")==0) return SmbGdnEnum;
    1113               else if (strcmp(name,"SmbGdnini")==0) return SmbGdniniEnum;
     1123         else stage=10;
     1124   }
     1125   if(stage==10){
     1126              if (strcmp(name,"SmbGdnini")==0) return SmbGdniniEnum;
    11141127              else if (strcmp(name,"SmbGsp")==0) return SmbGspEnum;
    11151128              else if (strcmp(name,"SmbGspini")==0) return SmbGspiniEnum;
    … …  
    11211134              else if (strcmp(name,"SmbIsInitialized")==0) return SmbIsInitializedEnum;
    11221135              else if (strcmp(name,"SmbMAdd")==0) return SmbMAddEnum;
    1123          else stage=10;
    1124    }
    1125    if(stage==10){
    1126               if (strcmp(name,"SmbMassBalance")==0) return SmbMassBalanceEnum;
     1136              else if (strcmp(name,"SmbMassBalance")==0) return SmbMassBalanceEnum;
    11271137              else if (strcmp(name,"SmbMassBalanceSnow")==0) return SmbMassBalanceSnowEnum;
    11281138              else if (strcmp(name,"SmbMassBalanceIce")==0) return SmbMassBalanceIceEnum;
    … …  
    11361146              else if (strcmp(name,"SmbMelt")==0) return SmbMeltEnum;
    11371147              else if (strcmp(name,"SmbMonthlytemperatures")==0) return SmbMonthlytemperaturesEnum;
     1148              else if (strcmp(name,"SmbMonthlydsradiation")==0) return SmbMonthlydsradiationEnum;
     1149              else if (strcmp(name,"SmbMonthlydlradiation")==0) return SmbMonthlydlradiationEnum;
     1150              else if (strcmp(name,"SmbMonthlywindspeed")==0) return SmbMonthlywindspeedEnum;
     1151              else if (strcmp(name,"SmbMonthlyairhumidity")==0) return SmbMonthlyairhumidityEnum;
    11381152              else if (strcmp(name,"SmbMSurf")==0) return SmbMSurfEnum;
    11391153              else if (strcmp(name,"SmbNetLW")==0) return SmbNetLWEnum;
    … …  
    11451159              else if (strcmp(name,"SmbPrecipitation")==0) return SmbPrecipitationEnum;
    11461160              else if (strcmp(name,"SmbPrecipitationsAnomaly")==0) return SmbPrecipitationsAnomalyEnum;
     1161              else if (strcmp(name,"SmbDsradiationAnomaly")==0) return SmbDsradiationAnomalyEnum;
     1162              else if (strcmp(name,"SmbDlradiationAnomaly")==0) return SmbDlradiationAnomalyEnum;
     1163              else if (strcmp(name,"SmbWindspeedAnomaly")==0) return SmbWindspeedAnomalyEnum;
     1164              else if (strcmp(name,"SmbAirhumidityAnomaly")==0) return SmbAirhumidityAnomalyEnum;
    11471165              else if (strcmp(name,"SmbPrecipitationsLgm")==0) return SmbPrecipitationsLgmEnum;
    11481166              else if (strcmp(name,"SmbPrecipitationsPresentday")==0) return SmbPrecipitationsPresentdayEnum;
    … …  
    11641182              else if (strcmp(name,"SmbSmbref")==0) return SmbSmbrefEnum;
    11651183              else if (strcmp(name,"SmbSzaValue")==0) return SmbSzaValueEnum;
     1184              else if (strcmp(name,"SmbSummerMelt")==0) return SmbSummerMeltEnum;
     1185              else if (strcmp(name,"SmbSummerAlbedo")==0) return SmbSummerAlbedoEnum;
     1186              else if (strcmp(name,"SmbSnowheight")==0) return SmbSnowheightEnum;
    11661187              else if (strcmp(name,"SmbT")==0) return SmbTEnum;
    11671188              else if (strcmp(name,"SmbTa")==0) return SmbTaEnum;
    … …  
    12231244              else if (strcmp(name,"SurfaceLogVxVyMisfit")==0) return SurfaceLogVxVyMisfitEnum;
    12241245              else if (strcmp(name,"SurfaceObservation")==0) return SurfaceObservationEnum;
    1225               else if (strcmp(name,"SurfaceRelVelMisfit")==0) return SurfaceRelVelMisfitEnum;
     1246         else stage=11;
     1247   }
     1248   if(stage==11){
     1249              if (strcmp(name,"SurfaceRelVelMisfit")==0) return SurfaceRelVelMisfitEnum;
    12261250              else if (strcmp(name,"SurfaceSlopeX")==0) return SurfaceSlopeXEnum;
    12271251              else if (strcmp(name,"SurfaceSlopeY")==0) return SurfaceSlopeYEnum;
    … …  
    12441268              else if (strcmp(name,"ThicknessResidual")==0) return ThicknessResidualEnum;
    12451269              else if (strcmp(name,"TransientAccumulatedDeltaIceThickness")==0) return TransientAccumulatedDeltaIceThicknessEnum;
    1246          else stage=11;
    1247    }
    1248    if(stage==11){
    1249               if (strcmp(name,"Vel")==0) return VelEnum;
     1270              else if (strcmp(name,"Vel")==0) return VelEnum;
    12501271              else if (strcmp(name,"VxAverage")==0) return VxAverageEnum;
    12511272              else if (strcmp(name,"VxBase")==0) return VxBaseEnum;
    … …  
    13461367              else if (strcmp(name,"Outputdefinition63")==0) return Outputdefinition63Enum;
    13471368              else if (strcmp(name,"Outputdefinition64")==0) return Outputdefinition64Enum;
    1348               else if (strcmp(name,"Outputdefinition65")==0) return Outputdefinition65Enum;
     1369         else stage=12;
     1370   }
     1371   if(stage==12){
     1372              if (strcmp(name,"Outputdefinition65")==0) return Outputdefinition65Enum;
    13491373              else if (strcmp(name,"Outputdefinition66")==0) return Outputdefinition66Enum;
    13501374              else if (strcmp(name,"Outputdefinition67")==0) return Outputdefinition67Enum;
    … …  
    13671391              else if (strcmp(name,"Outputdefinition82")==0) return Outputdefinition82Enum;
    13681392              else if (strcmp(name,"Outputdefinition83")==0) return Outputdefinition83Enum;
    1369          else stage=12;
    1370    }
    1371    if(stage==12){
    1372               if (strcmp(name,"Outputdefinition84")==0) return Outputdefinition84Enum;
     1393              else if (strcmp(name,"Outputdefinition84")==0) return Outputdefinition84Enum;
    13731394              else if (strcmp(name,"Outputdefinition85")==0) return Outputdefinition85Enum;
    13741395              else if (strcmp(name,"Outputdefinition86")==0) return Outputdefinition86Enum;
    … …  
    14691490              else if (strcmp(name,"DepthAverageAnalysis")==0) return DepthAverageAnalysisEnum;
    14701491              else if (strcmp(name,"DeviatoricStressErrorEstimator")==0) return DeviatoricStressErrorEstimatorEnum;
    1471               else if (strcmp(name,"Divergence")==0) return DivergenceEnum;
     1492         else stage=13;
     1493   }
     1494   if(stage==13){
     1495              if (strcmp(name,"Divergence")==0) return DivergenceEnum;
    14721496              else if (strcmp(name,"Domain3Dsurface")==0) return Domain3DsurfaceEnum;
    14731497              else if (strcmp(name,"DoubleArrayInput")==0) return DoubleArrayInputEnum;
    … …  
    14901514              else if (strcmp(name,"ExtrapolationAnalysis")==0) return ExtrapolationAnalysisEnum;
    14911515              else if (strcmp(name,"ExtrudeFromBaseAnalysis")==0) return ExtrudeFromBaseAnalysisEnum;
    1492          else stage=13;
    1493    }
    1494    if(stage==13){
    1495               if (strcmp(name,"ExtrudeFromTopAnalysis")==0) return ExtrudeFromTopAnalysisEnum;
     1516              else if (strcmp(name,"ExtrudeFromTopAnalysis")==0) return ExtrudeFromTopAnalysisEnum;
    14961517              else if (strcmp(name,"FSApproximation")==0) return FSApproximationEnum;
    14971518              else if (strcmp(name,"FSSolver")==0) return FSSolverEnum;
    … …  
    15921613              else if (strcmp(name,"LoveLf")==0) return LoveLfEnum;
    15931614              else if (strcmp(name,"LoveLt")==0) return LoveLtEnum;
    1594               else if (strcmp(name,"LoveTidalHt")==0) return LoveTidalHtEnum;
     1615         else stage=14;
     1616   }
     1617   if(stage==14){
     1618              if (strcmp(name,"LoveTidalHt")==0) return LoveTidalHtEnum;
    15951619              else if (strcmp(name,"LoveTidalKt")==0) return LoveTidalKtEnum;
    15961620              else if (strcmp(name,"LoveTidalLt")==0) return LoveTidalLtEnum;
    … …  
    16131637              else if (strcmp(name,"Materials")==0) return MaterialsEnum;
    16141638              else if (strcmp(name,"Matestar")==0) return MatestarEnum;
    1615          else stage=14;
    1616    }
    1617    if(stage==14){
    1618               if (strcmp(name,"Matice")==0) return MaticeEnum;
     1639              else if (strcmp(name,"Matice")==0) return MaticeEnum;
    16191640              else if (strcmp(name,"Matlitho")==0) return MatlithoEnum;
    16201641              else if (strcmp(name,"Mathydro")==0) return MathydroEnum;
    … …  
    16951716              else if (strcmp(name,"SMBarma")==0) return SMBarmaEnum;
    16961717              else if (strcmp(name,"SMBcomponents")==0) return SMBcomponentsEnum;
    1697               else if (strcmp(name,"SMBdebrisML")==0) return SMBdebrisMLEnum;
     1718              else if (strcmp(name,"SMBdebrisEvatt")==0) return SMBdebrisEvattEnum;
    16981719              else if (strcmp(name,"SMBd18opdd")==0) return SMBd18opddEnum;
    16991720              else if (strcmp(name,"SMBforcing")==0) return SMBforcingEnum;
    … …  
    17151736              else if (strcmp(name,"SealevelEmotion")==0) return SealevelEmotionEnum;
    17161737              else if (strcmp(name,"SealevelchangePolarMotionX")==0) return SealevelchangePolarMotionXEnum;
    1717               else if (strcmp(name,"SealevelchangePolarMotionY")==0) return SealevelchangePolarMotionYEnum;
     1738         else stage=15;
     1739   }
     1740   if(stage==15){
     1741              if (strcmp(name,"SealevelchangePolarMotionY")==0) return SealevelchangePolarMotionYEnum;
    17181742              else if (strcmp(name,"SealevelchangePolarMotionZ")==0) return SealevelchangePolarMotionZEnum;
    17191743              else if (strcmp(name,"SealevelchangePolarMotion")==0) return SealevelchangePolarMotionEnum;
    … …  
    17361760              else if (strcmp(name,"SpcTransient")==0) return SpcTransientEnum;
    17371761              else if (strcmp(name,"Sset")==0) return SsetEnum;
    1738          else stage=15;
    1739    }
    1740    if(stage==15){
    1741               if (strcmp(name,"StatisticsSolution")==0) return StatisticsSolutionEnum;
     1762              else if (strcmp(name,"StatisticsSolution")==0) return StatisticsSolutionEnum;
    17421763              else if (strcmp(name,"SteadystateSolution")==0) return SteadystateSolutionEnum;
    17431764              else if (strcmp(name,"StressIntensityFactor")==0) return StressIntensityFactorEnum;

  • issm/trunk-jpl/src/c/shared/io/Marshalling/IoCodeConversions.cpp

    r27852 r27856  
    262262                case 12: return SMBsemicEnum;   
    263263                case 13: return SMBarmaEnum;
    264                 case 14: return SMBdebrisMLEnum;
     264                case 14: return SMBdebrisEvattEnum;
    265265                default: _error_("Marshalled SMB code \""<<enum_in<<"\" not supported yet");
    266266        }
Note: See TracChangeset for help on using the changeset viewer.