Changeset 22181


Ignore:
Timestamp:
10/20/17 16:28:00 (7 years ago)
Author:
youngmc3
Message:

CHG: adding calving parameterizations (crevasse-depth and height-above-buoyancy laws), minor changes for calvingdev and levermann

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

Legend:

Unmodified
Added
Removed

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

    r22044 r22181  
    6868                        iomodel->FetchDataToInput(elements,"md.calving.meltingrate",CalvingMeltingrateEnum);
    6969                        break;
     70                case CalvingHabEnum:
     71                        iomodel->FetchDataToInput(elements,"md.calving.meltingrate",CalvingMeltingrateEnum);
     72                        break;
     73                case CalvingCrevasseDepthEnum:
     74                        iomodel->FetchDataToInput(elements,"md.calving.meltingrate",CalvingMeltingrateEnum);
     75                        iomodel->FetchDataToInput(elements,"md.calving.water_height",WaterheightEnum);
     76                        break;
    7077                default:
    7178                        _error_("Calving law "<<EnumToStringx(calvinglaw)<<" not supported yet");
    … …  
    8693                case CalvingMinthicknessEnum:
    8794                        parameters->AddObject(iomodel->CopyConstantObject("md.calving.min_thickness",CalvingMinthicknessEnum));
     95                        break;
     96                case CalvingHabEnum:
     97                        parameters->AddObject(iomodel->CopyConstantObject("md.calving.flotation_fraction",CalvingHabEnum));
     98                        break;
     99                case CalvingCrevasseDepthEnum:
     100                        parameters->AddObject(iomodel->CopyConstantObject("md.calving.critical_fraction",CalvingCrevasseDepthEnum));
    88101                        break;
    89102                default:
    … …  
    235248                        meltingrate_input = basalelement->GetInput(CalvingMeltingrateEnum);     _assert_(meltingrate_input);
    236249                        break;
     250                case CalvingHabEnum:
     251                        lsf_slopex_input  = basalelement->GetInput(LevelsetfunctionSlopeXEnum); _assert_(lsf_slopex_input);
     252                        if(dim==2) lsf_slopey_input  = basalelement->GetInput(LevelsetfunctionSlopeYEnum); _assert_(lsf_slopey_input);
     253                        meltingrate_input = basalelement->GetInput(CalvingMeltingrateEnum);     _assert_(meltingrate_input);
     254                        break;
     255                case CalvingCrevasseDepthEnum:
     256                        lsf_slopex_input  = basalelement->GetInput(LevelsetfunctionSlopeXEnum); _assert_(lsf_slopex_input);
     257                        if(dim==2) lsf_slopey_input  = basalelement->GetInput(LevelsetfunctionSlopeYEnum); _assert_(lsf_slopey_input);
     258                        calvingrate_input = basalelement->GetInput(CalvingCalvingrateEnum);     _assert_(calvingrate_input);
     259                        meltingrate_input = basalelement->GetInput(CalvingMeltingrateEnum);     _assert_(meltingrate_input);
     260                        break;
    237261                default:
    238262                        _error_("Calving law "<<EnumToStringx(calvinglaw)<<" not supported yet");
    … …  
    314338                                 for(i=0;i<dim;i++){
    315339                                         c[i]=0.;
     340                                         m[i]=meltingrate*dlsf[i]/norm_dlsf;
     341                                 }
     342                                else
     343                                 for(i=0;i<dim;i++){
     344                                         c[i]=0.;
     345                                         m[i]=0.;
     346                                 }
     347                                break;
     348                       
     349                        case CalvingHabEnum:
     350                                lsf_slopex_input->GetInputValue(&dlsf[0],gauss);
     351                                if(dim==2) lsf_slopey_input->GetInputValue(&dlsf[1],gauss);
     352                                meltingrate_input->GetInputValue(&meltingrate,gauss);
     353
     354                                norm_dlsf=0.;
     355                                for(i=0;i<dim;i++) norm_dlsf+=pow(dlsf[i],2);
     356                                norm_dlsf=sqrt(norm_dlsf);
     357
     358                                if(norm_dlsf>1.e-10)
     359                                 for(i=0;i<dim;i++){
     360                                         c[i]=0.;
     361                                         m[i]=meltingrate*dlsf[i]/norm_dlsf;
     362                                 }
     363                                else
     364                                 for(i=0;i<dim;i++){
     365                                         c[i]=0.;
     366                                         m[i]=0.;
     367                                 }
     368                                break;
     369                       
     370                        case CalvingCrevasseDepthEnum:
     371                                lsf_slopex_input->GetInputValue(&dlsf[0],gauss);
     372                                if(dim==2) lsf_slopey_input->GetInputValue(&dlsf[1],gauss);
     373                                calvingrate_input->GetInputValue(&calvingrate,gauss);
     374                                meltingrate_input->GetInputValue(&meltingrate,gauss);
     375
     376                                /*Limit calving rate to c <= v + 3 km/yr */
     377                                vel=sqrt(v[0]*v[0] + v[1]*v[1]);
     378                                if(calvingrate>calvingmax+vel) calvingrate = vel+calvingmax;
     379                                if(groundedice<0) meltingrate = 0.;
     380                               
     381                                norm_dlsf=0.;
     382                                for(i=0;i<dim;i++) norm_dlsf+=pow(dlsf[i],2);
     383                                norm_dlsf=sqrt(norm_dlsf);
     384
     385                                if(norm_dlsf>1.e-10)
     386                                 for(i=0;i<dim;i++){
     387                                         c[i]=calvingrate*dlsf[i]/norm_dlsf;
    316388                                         m[i]=meltingrate*dlsf[i]/norm_dlsf;
    317389                                 }
    … …  
    608680        /*Intermediaries*/
    609681        int         calvinglaw;
    610         IssmDouble  min_thickness,thickness;
     682        IssmDouble  min_thickness,thickness,flotation_fraction;
     683        IssmDouble  rho_ice,rho_water,constant_g,rheology_B,rheology_n;
     684        IssmDouble  bed,water_depth;
     685
    611686        femmodel->parameters->FindParam(&calvinglaw,CalvingLawEnum);
    612687
    … …  
    640715                }
    641716        }
     717       
     718        if(calvinglaw==CalvingHabEnum){
     719
     720                /*Get the fraction of the flotation thickness at the terminus*/
     721                femmodel->parameters->FindParam(&flotation_fraction,CalvingHabEnum);
     722
     723                /*Loop over all elements of this partition*/
     724                for(int i=0;i<femmodel->elements->Size();i++){
     725                        Element* element  = xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
     726                       
     727                        rho_ice = element->GetMaterialParameter(MaterialsRhoIceEnum);
     728                        rho_water = element->GetMaterialParameter(MaterialsRhoSeawaterEnum);
     729
     730                        int      numnodes = element->GetNumberOfNodes();
     731                        Gauss*   gauss    = element->NewGauss();
     732                        Input*   H_input  = element->GetInput(ThicknessEnum); _assert_(H_input);
     733                        Input*   bed      = element->GetInput(BedEnum); _assert_(bed);
     734
     735                        /*Potentially constrain nodes of this element*/
     736                        for(int in=0;in<numnodes;in++){
     737                                gauss->GaussNode(element->GetElementType(),in);
     738                                Node* node=element->GetNode(in);
     739                                H_input->GetInputValue(&thickness,gauss);
     740                                bed->GetInputValue(&water_depth,gauss);
     741                                if(thickness<((rho_water/rho_ice)*(1+flotation_fraction)*-water_depth)){
     742                                        node->ApplyConstraint(0,+1.);
     743                                }
     744                                else {
     745                                        /* no ice, set no spc */
     746                                        node->DofInFSet(0);
     747                                }
     748                        }
     749                        delete gauss;
     750                }
     751        }
     752       
    642753        /*Default, do nothing*/
    643754        return;

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

    r22136 r22181  
    23562356                                        this->CalvingRateDev();
    23572357                                        break;
     2358                                case CalvingCrevasseDepthEnum:
     2359                                        this->CalvingCrevasseDepth();
     2360                                        break;
    23582361                                default:
    23592362                                        _error_("Calving law "<<EnumToStringx(calvinglaw)<<" not supported yet");
    … …  
    23622365                case StrainRateparallelEnum: this->StrainRateparallel(); break;
    23632366                case StrainRateperpendicularEnum: this->StrainRateperpendicular(); break;
     2367                case SurfaceCrevasseEnum: this->CalvingCrevasseDepth(); break;
     2368                case SigmaVMEnum: this->CalvingRateDev(); break;
    23642369        }
    23652370

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

    r22012 r22181  
    189189                virtual void             BasalNodeIndices(int* pnumindices,int** pindices,int finiteelement){_error_("not implemented yet");};
    190190                virtual void       CalvingRateDev(void){_error_("not implemented yet");};
     191                virtual void       CalvingCrevasseDepth(void){_error_("not implemented yet");};
    191192                virtual void        CalvingRateLevermann(void)=0;
    192193                virtual IssmDouble CharacteristicLength(void)=0;

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

    r22178 r22181  
    216216        IssmDouble  calvingrate[NUMVERTICES];
    217217        IssmDouble  lambda1,lambda2,ex,ey,vx,vy,vel;
    218         IssmDouble  sigma_vm,sigma_max,sigma_max_floating,sigma_max_grounded;
     218        IssmDouble  sigma_vm[NUMVERTICES];
     219        IssmDouble  sigma_max,sigma_max_floating,sigma_max_grounded;
    219220        IssmDouble  epse_2,groundedice,bed;
    220221
    … …  
    260261                /*Calculate sigma_vm*/
    261262                epse_2    = 1./2. *(lambda1*lambda1 + lambda2*lambda2);
    262                 sigma_vm  = sqrt(3.) * B * pow(epse_2,1./(2.*n));
     263                sigma_vm[iv]  = sqrt(3.) * B * pow(epse_2,1./(2.*n));
    263264
    264265                /*OLD (keep for a little bit)*/
    … …  
    279280                }
    280281                else{
    281                         calvingratex[iv]=vx*sigma_vm/sigma_max;
    282                         calvingratey[iv]=vy*sigma_vm/sigma_max;
     282                        calvingratex[iv]=vx*sigma_vm[iv]/sigma_max;
     283                        calvingratey[iv]=vy*sigma_vm[iv]/sigma_max;
    283284                }
    284285                calvingrate[iv] =sqrt(calvingratex[iv]*calvingratex[iv] + calvingratey[iv]*calvingratey[iv]);
    … …  
    289290        this->inputs->AddInput(new TriaInput(CalvingrateyEnum,&calvingratey[0],P1Enum));
    290291        this->inputs->AddInput(new TriaInput(CalvingCalvingrateEnum,&calvingrate[0],P1Enum));
     292        this->inputs->AddInput(new TriaInput(SigmaVMEnum,&sigma_vm[0],P1Enum));
    291293
    292294        /*Clean up and return*/
     295        delete gauss;
     296}
     297/*}}}*/
     298void       Tria::CalvingCrevasseDepth(){/*{{{*/
     299       
     300        IssmDouble  xyz_list[NUMVERTICES][3];
     301        IssmDouble  calvingrate[NUMVERTICES];
     302        IssmDouble  vx,vy,vel;
     303        IssmDouble  critical_fraction,water_height;
     304        IssmDouble  bathymetry,Ho,thickness,float_depth,groundedice;
     305        IssmDouble  surface_crevasse[NUMVERTICES], basal_crevasse[NUMVERTICES], crevasse_depth[NUMVERTICES], H_surf, H_surfbasal;
     306        IssmDouble  strainparallel, straineffective;
     307        IssmDouble  yts;
     308
     309        /* Get node coordinates and dof list: */
     310        ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
     311               
     312        /*Get the critical fraction of thickness surface and basal crevasses penetrate for calving onset*/
     313        this->parameters->FindParam(&critical_fraction,CalvingCrevasseDepthEnum);
     314        this->parameters->FindParam(&yts,ConstantsYtsEnum);
     315               
     316        IssmDouble rho_ice        = this->GetMaterialParameter(MaterialsRhoIceEnum);
     317        IssmDouble rho_seawater   = this->GetMaterialParameter(MaterialsRhoSeawaterEnum);
     318        IssmDouble rho_freshwater = this->GetMaterialParameter(MaterialsRhoFreshwaterEnum);
     319        IssmDouble constant_g     = this->GetMaterialParameter(ConstantsGEnum);
     320        IssmDouble rheology_B     = this->GetMaterialParameter(MaterialsRheologyBbarEnum);
     321        IssmDouble rheology_n     = this->GetMaterialParameter(MaterialsRheologyNEnum);
     322       
     323        Input*   H_input       = inputs->GetInput(ThicknessEnum); _assert_(H_input);
     324        Input*   bed           = inputs->GetInput(BedEnum); _assert_(bed);
     325        Input*   surface       = inputs->GetInput(SurfaceEnum); _assert_(surface);
     326        Input*  strainrateparallel  = inputs->GetInput(StrainRateparallelEnum);  _assert_(strainrateparallel);
     327        Input*  strainrateeffective = inputs->GetInput(StrainRateeffectiveEnum); _assert_(strainrateeffective);
     328        Input*  vx_input = inputs->GetInput(VxEnum); _assert_(vx_input);
     329        Input*  vy_input = inputs->GetInput(VxEnum); _assert_(vy_input);
     330        Input*  gr_input = inputs->GetInput(MaskGroundediceLevelsetEnum); _assert_(gr_input);
     331        Input*   waterheight_input = inputs->GetInput(WaterheightEnum); _assert_(waterheight_input);
     332
     333        /*Loop over all elements of this partition*/
     334        GaussTria* gauss=new GaussTria();
     335        for (int iv=0;iv<NUMVERTICES;iv++){
     336                gauss->GaussVertex(iv);
     337       
     338                H_input->GetInputValue(&thickness,gauss);
     339                bed->GetInputValue(&bathymetry,gauss);
     340                surface->GetInputValue(&float_depth,gauss);
     341                strainrateparallel->GetInputValue(&strainparallel,gauss);
     342                strainrateeffective->GetInputValue(&straineffective,gauss);
     343                vx_input->GetInputValue(&vx,gauss);
     344                vy_input->GetInputValue(&vy,gauss);
     345                gr_input->GetInputValue(&groundedice,gauss);
     346                waterheight_input->GetInputValue(&water_height,gauss);
     347                vel=sqrt(vx*vx+vy*vy)+1.e-14;
     348
     349                Ho = thickness - (rho_seawater/rho_ice) * (-bathymetry);
     350                if(Ho<0.)  Ho=0.;
     351
     352                /*Otero2010: balance between the tensile deviatoric stress and ice overburden pressure*/
     353                /*surface crevasse*/
     354                //surface_crevasse[iv] = rheology_B * strainparallel * pow(straineffective, ((1 / rheology_n)-1)) / (rho_ice * constant_g);
     355                surface_crevasse[iv] = 2 * rheology_B * pow(max(strainparallel,0.),(1/rheology_n)) / (rho_ice * constant_g);
     356                if (surface_crevasse[iv]<0.) {
     357                        surface_crevasse[iv]=0.;
     358                        water_height = 0.;
     359                }
     360                if (surface_crevasse[iv]<water_height){
     361                        water_height = surface_crevasse[iv];
     362                }
     363               
     364                /*basal crevasse*/
     365                //basal_crevasse[iv] = (rho_ice/(rho_seawater-rho_ice)) * (rheology_B * strainparallel * pow(straineffective,((1/rheology_n)-1)) / (rho_ice*constant_g) - Ho);
     366                basal_crevasse[iv] = (rho_ice/(rho_seawater-rho_ice)) * (2 * rheology_B * pow(max(strainparallel,0.),(1/rheology_n)) / (rho_ice*constant_g) - Ho);
     367                if (basal_crevasse[iv]<0.) basal_crevasse[iv]=0.;
     368                if (bathymetry>0.) basal_crevasse[iv] = 0.;
     369       
     370                H_surf = surface_crevasse[iv] + (rho_freshwater/rho_ice)*water_height - critical_fraction*float_depth;
     371                H_surfbasal = (surface_crevasse[iv] + (rho_freshwater/rho_ice)*water_height + basal_crevasse[iv])-(critical_fraction*thickness);
     372               
     373                crevasse_depth[iv] = max(H_surf,H_surfbasal);
     374       
     375                /*Assign values */
     376                if(crevasse_depth[iv]>=0. && bathymetry<=0.){
     377                 calvingrate[iv] = vel+3000./yts;
     378                }       
     379                else
     380                 calvingrate[iv]=0.;
     381        }
     382
     383        this->inputs->AddInput(new TriaInput(SurfaceCrevasseEnum,&surface_crevasse[0],P1Enum));
     384        this->inputs->AddInput(new TriaInput(BasalCrevasseEnum,&basal_crevasse[0],P1Enum));
     385        this->inputs->AddInput(new TriaInput(CrevasseDepthEnum,&crevasse_depth[0],P1Enum));
     386        this->inputs->AddInput(new TriaInput(CalvingCalvingrateEnum,&calvingrate[0],P1Enum));
     387
    293388        delete gauss;
    294389}
    … …  
    331426
    332427                /*Calving rate proportionnal to the positive product of the strain rate along the ice flow direction and the strain rate perpendicular to the ice flow */
    333                 calvingrate[iv]=propcoeff*strainparallel*strainperpendicular;
    334                 if(calvingrate[iv]<0. || bed>0.){
     428                if(strainparallel>0. && strainperpendicular>0. && bed<=0.){
     429                        calvingrate[iv]=propcoeff*strainparallel*strainperpendicular;
     430                }
     431                else
    335432                        calvingrate[iv]=0.;
    336                 }
     433               
    337434                calvingratex[iv]=calvingrate[iv]*vx/(sqrt(vel)+1.e-14);
    338435                calvingratey[iv]=calvingrate[iv]*vy/(sqrt(vel)+1.e-14);

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

    r21931 r22181  
    5353                void        AverageOntoPartition(Vector<IssmDouble>* partition_contributions,Vector<IssmDouble>* partition_areas,IssmDouble* vertex_response,IssmDouble* qmu_part);
    5454                void                    CalvingRateDev();
     55                void        CalvingCrevasseDepth();
    5556                void                    CalvingRateLevermann();
    5657                IssmDouble  CharacteristicLength(void);

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

    r22116 r22181  
    19401940}
    19411941/*}}}*/
     1942void FemModel::StrainRateeffectivex(){/*{{{*/
     1943
     1944        for(int i=0;i<elements->Size();i++){
     1945                Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(i));
     1946                element->ComputeStrainRate();
     1947        }
     1948}
     1949/*}}}*/
    19421950void FemModel::StressIntensityFactorx(){/*{{{*/
    19431951

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

    r22100 r22181  
    110110                void StrainRateparallelx();
    111111                void StrainRateperpendicularx();
     112                void StrainRateeffectivex();
    112113                void StressIntensityFactorx();
    113114                void TotalFloatingBmbx(IssmDouble* pFbmb);

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

    r20723 r22181  
    1818                case CalvingMinthicknessEnum:
    1919                        break;
     20                case CalvingHabEnum:
     21                        break;
     22                case CalvingCrevasseDepthEnum:
     23                        femmodel->StrainRateparallelx();
     24                        femmodel->StrainRateeffectivex();
     25                        femmodel->ElementOperationx(&Element::CalvingCrevasseDepth);
     26                        break;
    2027                case CalvingLevermannEnum:
    2128                        if(VerboseModule()) _printf0_("   computing Levermann's calving rate\n");

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

    r22100 r22181  
    258258        CalvingDevEnum,
    259259        CalvingMinthicknessEnum,
     260        CalvingHabEnum,
     261        CalvingCrevasseDepthEnum,
     262        SurfaceCrevasseEnum,
     263        BasalCrevasseEnum,
     264        CrevasseDepthEnum,
     265        WaterheightEnum,
    260266        DefaultCalvingEnum,
    261267        CalvinglevermannCoeffEnum,
    … …  
    269275        CalvingStressThresholdFloatingiceEnum,
    270276        CalvingMaxEnum,
     277        SigmaVMEnum,
    271278        StrainRateparallelEnum,
    272279        StrainRateperpendicularEnum,

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

    r22100 r22181  
    264264                case CalvingDevEnum : return "CalvingDev";
    265265                case CalvingMinthicknessEnum : return "CalvingMinthickness";
     266                case CalvingHabEnum : return "CalvingHab";
     267                case CalvingCrevasseDepthEnum : return "CalvingCrevasseDepth";
     268                case SurfaceCrevasseEnum : return "SurfaceCrevasse";
     269                case BasalCrevasseEnum : return "BasalCrevasse";
     270                case CrevasseDepthEnum : return "CrevasseDepth";
     271                case WaterheightEnum : return "Waterheight";
    266272                case DefaultCalvingEnum : return "DefaultCalving";
    267273                case CalvinglevermannCoeffEnum : return "CalvinglevermannCoeff";
    … …  
    275281                case CalvingStressThresholdFloatingiceEnum : return "CalvingStressThresholdFloatingice";
    276282                case CalvingMaxEnum : return "CalvingMax";
     283                case SigmaVMEnum : return "SigmaVM";
    277284                case StrainRateparallelEnum : return "StrainRateparallel";
    278285                case StrainRateperpendicularEnum : return "StrainRateperpendicular";

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

    r22100 r22181  
    270270              else if (strcmp(name,"CalvingDev")==0) return CalvingDevEnum;
    271271              else if (strcmp(name,"CalvingMinthickness")==0) return CalvingMinthicknessEnum;
     272         else stage=3;
     273   }
     274   if(stage==3){
     275              if (strcmp(name,"CalvingHab")==0) return CalvingHabEnum;
     276              else if (strcmp(name,"CalvingCrevasseDepth")==0) return CalvingCrevasseDepthEnum;
     277              else if (strcmp(name,"SurfaceCrevasse")==0) return SurfaceCrevasseEnum;
     278              else if (strcmp(name,"BasalCrevasse")==0) return BasalCrevasseEnum;
     279              else if (strcmp(name,"CrevasseDepth")==0) return CrevasseDepthEnum;
     280              else if (strcmp(name,"Waterheight")==0) return WaterheightEnum;
    272281              else if (strcmp(name,"DefaultCalving")==0) return DefaultCalvingEnum;
    273282              else if (strcmp(name,"CalvinglevermannCoeff")==0) return CalvinglevermannCoeffEnum;
    … …  
    281290              else if (strcmp(name,"CalvingStressThresholdFloatingice")==0) return CalvingStressThresholdFloatingiceEnum;
    282291              else if (strcmp(name,"CalvingMax")==0) return CalvingMaxEnum;
     292              else if (strcmp(name,"SigmaVM")==0) return SigmaVMEnum;
    283293              else if (strcmp(name,"StrainRateparallel")==0) return StrainRateparallelEnum;
    284294              else if (strcmp(name,"StrainRateperpendicular")==0) return StrainRateperpendicularEnum;
    … …  
    757767              if (strcmp(name,"RootPath")==0) return RootPathEnum;
    758768              else if (strcmp(name,"OutputFileName")==0) return OutputFileNameEnum;
    759               else if (strcmp(name,"InputFileName")==0) return InputFileNameEnum;
     769         else stage=7;
     770   }
     771   if(stage==7){
     772              if (strcmp(name,"InputFileName")==0) return InputFileNameEnum;
    760773              else if (strcmp(name,"LockFileName")==0) return LockFileNameEnum;
    761774              else if (strcmp(name,"RestartFileName")==0) return RestartFileNameEnum;
    … …  
    919932              else if (strcmp(name,"NodeSId")==0) return NodeSIdEnum;
    920933              else if (strcmp(name,"ElementSId")==0) return ElementSIdEnum;
    921               else if (strcmp(name,"VectorParam")==0) return VectorParamEnum;
     934         else stage=8;
     935   }
     936   if(stage==8){
     937              if (strcmp(name,"VectorParam")==0) return VectorParamEnum;
    922938              else if (strcmp(name,"Riftfront")==0) return RiftfrontEnum;
    923939              else if (strcmp(name,"Segment")==0) return SegmentEnum;
    … …  
    10411057              else if (strcmp(name,"P1bubblecondensed")==0) return P1bubblecondensedEnum;
    10421058              else if (strcmp(name,"P2")==0) return P2Enum;
    1043               else if (strcmp(name,"P2bubble")==0) return P2bubbleEnum;
     1059         else stage=9;
     1060   }
     1061   if(stage==9){
     1062              if (strcmp(name,"P2bubble")==0) return P2bubbleEnum;
    10441063              else if (strcmp(name,"P2bubblecondensed")==0) return P2bubblecondensedEnum;
    10451064              else if (strcmp(name,"P2xP1")==0) return P2xP1Enum;

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

    r22066 r22181  
    151151                case 3: return CalvingLevermannEnum;
    152152                case 4: return CalvingMinthicknessEnum;
     153                case 5: return CalvingHabEnum;
     154                case 6: return CalvingCrevasseDepthEnum;
    153155                default: _error_("Marshalled Calving law code \""<<enum_in<<"\" not supported yet");
    154156        }
Note: See TracChangeset for help on using the changeset viewer.