source: issm/oecreview/Archive/24684-25833/ISSM-24943-24944.diff

Last change on this file was 25834, checked in by Mathieu Morlighem, 4 years ago

CHG: added 24684-25833
File size: 21.1 KB

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

     
    47444744        int* indices = NULL;
    47454745        int         gsize;
    47464746
     4747        bool computerigid = true;
     4748        bool computeelastic= true;
     4749
     4750        /*recover computational flags: */
     4751        this->parameters->FindParam(&computerigid,SealevelriseRigidEnum);
     4752        this->parameters->FindParam(&computeelastic,SealevelriseElasticEnum);
     4753
    47474754        /*Initialize temporary vector that will be used to sum eustatic components on all local elements, prior
    47484755         * to assembly:*/
    47494756        gsize = this->nodes->NumberOfDofs(GsetEnum);
    … …  
    47534760        /*Serialize vectors from previous iteration:*/
    47544761        RSLg_old=pRSLg_old->ToMPISerial();
    47554762
    4756         /*Call the sea level rise core: */
    4757         for(int i=0;i<elements->Size();i++){
    4758                 Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    4759                 element->SealevelriseNonEustatic(RSLgo,RSLg_old,masks, latitude,longitude,radius);
     4763        /*Call the sea level rise non-eustatic core only if required: */
     4764        if(computerigid | computeelastic){
     4765                for(int i=0;i<elements->Size();i++){
     4766                        Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
     4767                        element->SealevelriseNonEustatic(RSLgo,RSLg_old,masks, latitude,longitude,radius);
     4768                }
    47604769        }
    47614770        pRSLgo->SetValues(gsize,indices,RSLgo,ADD_VAL);
    47624771        pRSLgo->Assemble();

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

     
    55835583        int gsize;
    55845584        bool spherical=true;
    55855585        IssmDouble llr_list[NUMVERTICES][3];
    5586         IssmDouble area;
     5586        IssmDouble area,eartharea;
    55875587        IssmDouble I;  //change in ice thickness or water level(Farrel and Clarke, Equ. 4)
    5588         IssmDouble rho;
     5588        IssmDouble rho_earth;
    55895589        IssmDouble late,longe,re;
    55905590        IssmDouble lati,longi,ri;
     5591        IssmDouble constant;
    55915592
     5593        IssmDouble* G=NULL;
     5594        IssmDouble* G_elastic_precomputed=NULL;
     5595        IssmDouble* G_rigid_precomputed=NULL;
     5596
    55925597        /*elastic green function:*/
    55935598        IssmDouble* indices=NULL;
    55945599        int         M;
    5595         IssmDouble* dummypointer=NULL;
    55965600
    55975601        /*Computational flags:*/
    55985602        bool computerigid = true;
     5603        bool computeelastic = true;
    55995604
    5600         /*how many dofs are we working with here? */
     5605        /*recover parameters: */
     5606        rho_earth=FindParam(MaterialsEarthDensityEnum);
     5607        this->parameters->FindParam(&computerigid,SealevelriseRigidEnum);
     5608        this->parameters->FindParam(&computeelastic,SealevelriseElasticEnum);
    56015609        this->parameters->FindParam(&gsize,MeshNumberofverticesEnum);
     5610        this->parameters->FindParam(&eartharea,SealevelEarthAreaEnum);
    56025611
    5603         /*recover size of indexed tables:*/
     5612        /*recover precomputed green function kernels:*/
    56045613        DoubleVecParam* parameter = static_cast<DoubleVecParam*>(this->parameters->FindParamObject(SealevelriseGRigidEnum)); _assert_(parameter);
    5605         parameter->GetParameterValueByPointer(&dummypointer,&M);
     5614        parameter->GetParameterValueByPointer(&G_rigid_precomputed,&M);
    56065615
     5616        parameter = static_cast<DoubleVecParam*>(this->parameters->FindParamObject(SealevelriseGElasticEnum)); _assert_(parameter);
     5617        parameter->GetParameterValueByPointer(&G_elastic_precomputed,&M);
     5618       
    56075619        /*allocate indices:*/
    56085620        indices=xNew<IssmDouble>(gsize);
     5621        G=xNewZeroInit<IssmDouble>(gsize);
     5622       
     5623        /*compute area:*/
     5624        area=GetAreaSpherical();
    56095625
    56105626        /* Where is the centroid of this element?:{{{*/
    56115627
    … …  
    56455661        late=late/180*PI;
    56465662        longe=longe/180*PI;
    56475663        /*}}}*/
    5648 
     5664               
     5665        constant=3/rho_earth*area/eartharea;
     5666       
    56495667        for(int i=0;i<gsize;i++){
    56505668                IssmDouble alpha;
    56515669                IssmDouble delPhi,delLambda;
    … …  
    56545672                lati=latitude[i]/180*PI; longi=longitude[i]/180*PI;
    56555673                delPhi=fabs(lati-late); delLambda=fabs(longi-longe);
    56565674                alpha=2.*asin(sqrt(pow(sin(delPhi/2),2)+cos(lati)*cos(late)*pow(sin(delLambda/2),2)));
    5657                 indices[i]=reCast<int,IssmDouble>(alpha/PI*reCast<IssmDouble,int>(M-1));
     5675                indices[i]=alpha/PI*reCast<IssmDouble,int>(M-1);
     5676
     5677                /*Rigid earth gravitational perturbation: */
     5678                if(computerigid){
     5679                        G[i]+=G_rigid_precomputed[reCast<int,IssmDouble>(indices[i])];
     5680                }
     5681                if(computeelastic){
     5682                        G[i]+=G_elastic_precomputed[reCast<int,IssmDouble>(indices[i])];
     5683                }
     5684                G[i]=G[i]*constant;
    56585685        }
    56595686
    56605687        /*Add in inputs:*/
    56615688    this->inputs2->SetArrayInput(SealevelriseIndicesEnum,this->lid,indices,gsize);
     5689    this->inputs2->SetArrayInput(SealevelriseGEnum,this->lid,G,gsize);
     5690        this->inputs2->SetDoubleInput(AreaEnum,this->lid,area);
    56625691
    5663         /*Another quantity, area:*/
    5664         this->inputs2->SetDoubleInput(AreaEnum,this->lid,GetAreaSpherical());
     5692        /*Free allocations:*/
     5693        xDelete(indices);
     5694        xDelete(G);
    56655695
    56665696        return;
    56675697}
    … …  
    56895719void    Tria::SealevelriseEustaticIce(IssmDouble* Sgi, IssmDouble* peustatic, SealevelMasks* masks, IssmDouble* latitude,IssmDouble* longitude,IssmDouble* radius,IssmDouble oceanarea){ /*{{{*/
    56905720
    56915721        /*diverse:*/
    5692         int gsize,dummy;
    5693         bool spherical=true;
    5694         IssmDouble llr_list[NUMVERTICES][3];
    5695         IssmDouble area,eartharea;
     5722        int gsize;
     5723        IssmDouble area;
     5724        IssmDouble phi=1.0; //WARNING: do not touch this, default is entire elemnt contributes eustatic
    56965725        IssmDouble I;  //change in ice thickness or water level(Farrel and Clarke, Equ. 4)
    5697         IssmDouble rho;
    5698         IssmDouble late,longe,re;
    5699         IssmDouble lati,longi,ri;
    57005726        bool notfullygrounded=false;
    57015727
    57025728        /*elastic green function:*/
    5703         int         index;
    5704         IssmDouble* indices=NULL;
    5705         IssmDouble* G_elastic_precomputed=NULL;
    5706         IssmDouble* G_rigid_precomputed=NULL;
    5707         int         M;
     5729        IssmDouble* G=NULL;
    57085730
    57095731        /*ice properties: */
    57105732        IssmDouble rho_ice,rho_water,rho_earth;
    … …  
    57225744
    57235745        /*early return if we are not on an ice cap:*/
    57245746        if(!masks->isiceonly[this->lid]){
     5747                #ifdef _ISSM_DEBUG_
    57255748                constant=0; this->AddInput2(SealevelEustaticMaskEnum,&constant,P0Enum);
     5749                #endif
    57265750                *peustatic=0; //do not forget to assign this pointer, otherwise, global eustatic will be garbage!
    57275751                return;
    57285752        }
    … …  
    57295753
    57305754        /*early return if we are fully floating:*/
    57315755        if (masks->isfullyfloating[this->lid]){
    5732                 constant=0; this->AddInput2(SealevelEustaticMaskEnum,&constant,P0Enum);
     5756                constant=0;
     5757                #ifdef _ISSM_DEBUG_
     5758                this->AddInput2(SealevelEustaticMaskEnum,&constant,P0Enum);
     5759                #endif
    57335760                *peustatic=0; //do not forget to assign this pointer, otherwise, global eustatic will be garbage!
    57345761                return;
    57355762        }
    … …  
    57385765        if (masks->notfullygrounded[this->lid]) notfullygrounded=true; //used later on.
    57395766   
    57405767        /*Inform mask: */
    5741         constant=1; this->AddInput2(SealevelEustaticMaskEnum,&constant,P0Enum);
     5768        constant=1;
     5769        #ifdef _ISSM_DEBUG_
     5770        this->AddInput2(SealevelEustaticMaskEnum,&constant,P0Enum);
     5771        #endif
    57425772
    57435773        /*recover material parameters: */
    57445774        rho_ice=FindParam(MaterialsRhoIceEnum);
    57455775        rho_water=FindParam(MaterialsRhoSeawaterEnum);
    5746         rho_earth=FindParam(MaterialsEarthDensityEnum);
    57475776
    57485777        /*recover love numbers and computational flags: */
    5749         this->parameters->FindParam(&computerigid,SealevelriseRigidEnum);
    5750         this->parameters->FindParam(&computeelastic,SealevelriseElasticEnum);
    57515778        this->parameters->FindParam(&scaleoceanarea,SealevelriseOceanAreaScalingEnum);
    57525779
    5753         /*recover earth area: */
    5754         this->parameters->FindParam(&eartharea,SealevelEarthAreaEnum);
     5780        /*retrieve precomputed G:*/
     5781        this->inputs2->GetArrayPtr(SealevelriseGEnum,this->lid,&G,&gsize);
    57555782
    5756         /*recover precomputed green function kernels:*/
    5757         DoubleVecParam* parameter = static_cast<DoubleVecParam*>(this->parameters->FindParamObject(SealevelriseGRigidEnum)); _assert_(parameter);
    5758         parameter->GetParameterValueByPointer(&G_rigid_precomputed,&M);
    5759 
    5760         if(computeelastic){
    5761                 parameter = static_cast<DoubleVecParam*>(this->parameters->FindParamObject(SealevelriseGElasticEnum)); _assert_(parameter);
    5762                 parameter->GetParameterValueByPointer(&G_elastic_precomputed,&M);
    5763         }
    5764 
    5765         /*how many dofs are we working with here? */
    5766         this->parameters->FindParam(&gsize,MeshNumberofverticesEnum);
    5767 
    5768         /*retrieve indices:*/
    5769         if(computerigid){this->inputs2->GetArrayPtr(SealevelriseIndicesEnum,this->lid,&indices,&dummy); _assert_(dummy==gsize);}
    5770 
    57715783        /*Get area of element: precomputed in the sealevelrise_core_geometry:*/
    57725784        this->GetInput2Value(&area,AreaEnum);
    57735785
    5774         if(notfullygrounded){
    5775                 IssmDouble phi=0;
     5786        /*factor to reduce area if we are not fully grounded:*/
     5787        if(notfullygrounded){ /*{{{*/
    57765788                IssmDouble xyz_list[NUMVERTICES][3];
    57775789                ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    57785790
    57795791                phi=this->GetGroundedPortion(&xyz_list[0][0]); //watch out, this only works because of the Thales theorem! We are in 3D, but this routine is inherently for 2D trias
    5780                 area*=phi; //scale our load by the fraction of grounded area.
    57815792        }
     5793        /*}}}*/
    57825794
    57835795        /*Compute ice thickness: */
    57845796        Input2* deltathickness_input=this->GetInput2(SealevelriseDeltathicknessEnum);
    57855797        if (!deltathickness_input)_error_("delta thickness input needed to compute sea level rise!");
    57865798
    5787         /*If we are fully grounded, take the average over the element: */
     5799        /*If we are fully grounded, take the average over the element: {{{*/
    57885800        if(!notfullygrounded)deltathickness_input->GetInputAverage(&I);
    57895801        else{
    57905802                IssmDouble total_weight=0;
    … …  
    58095821                I=I/total_weight;
    58105822                delete gauss;
    58115823        }
     5824        /*}}}*/
    58125825
    58135826        /*Compute eustatic compoent:*/
    58145827        _assert_(oceanarea>0.);
    58155828        if(scaleoceanarea) oceanarea=3.619e+14; // use true ocean area, m^2
    5816         eustatic += rho_ice*area*I/(oceanarea*rho_water);
     5829        eustatic += rho_ice*area*phi*I/(oceanarea*rho_water);
    58175830
    5818         if(computeelastic | computerigid){
    5819                 IssmDouble alpha;
    5820                 IssmDouble delPhi,delLambda;
    5821                 for(int i=0;i<gsize;i++){
     5831        /*convert from m to kg/m^2:*/
     5832        I=I*rho_ice*phi;
    58225833
    5823                         IssmDouble G_elastic=0;  //do not remove =0!
     5834        /*convolve:*/
     5835        for(int i=0;i<gsize;i++) Sgi[i]+=G[i]*I;
    58245836
    5825                         /*Compute alpha angle between centroid and current vertex and index into precomputed tables: */
    5826                         /*lati=latitude[i]/180*PI; longi=longitude[i]/180*PI;
    5827                         delPhi=fabs(lati-late); delLambda=fabs(longi-longe);
    5828                         alpha=2.*asin(sqrt(pow(sin(delPhi/2),2.0)+cos(lati)*cos(late)*pow(sin(delLambda/2),2)));
    5829                         index=reCast<int,IssmDouble>(alpha/PI*reCast<IssmDouble,int>(M-1));*/
    5830                         index=reCast<int,IssmDouble>(indices[i]);
    5831 
    5832                         //Elastic component  (from Eq 17 in Adhikari et al, GMD 2015)
    5833                         if(computeelastic) G_elastic += G_elastic_precomputed[index];
    5834 
    5835                         /*Add all components to the Sgi or Sgo solution vectors:*/
    5836                         Sgi[i]+=3*rho_ice/rho_earth*area/eartharea*I*(G_rigid_precomputed[index]+G_elastic);
    5837                 }
    5838         }
    5839 
    58405837        /*Assign output pointer:*/
    58415838        _assert_(!xIsNan<IssmDouble>(eustatic));
    5842         _assert_(!xIsInf<IssmDouble>(eustatic));
    58435839        *peustatic=eustatic;
    58445840        return;
    58455841}
    … …  
    59975993
    59985994        /*diverse:*/
    59995995        int gsize,dummy;
    6000         bool spherical=true;
    6001         IssmDouble llr_list[NUMVERTICES][3];
    6002         IssmDouble area,eartharea;
    60035996        IssmDouble S;  //change in water water level(Farrel and Clarke, Equ. 4)
    6004         IssmDouble late,longe;
    6005         IssmDouble lati,longi,ri;
    6006         IssmDouble minlong=400;
    6007         IssmDouble maxlong=-20;
    60085997        IssmDouble constant=0;
     5998        IssmDouble rho_water;
     5999        IssmDouble* G=NULL;
    60096000
    6010         /*precomputed elastic green functions:*/
    6011         IssmDouble* G_rigid_precomputed = NULL;
    6012         IssmDouble* G_elastic_precomputed = NULL;
    6013         int         M;
    6014         int         index;
    6015         IssmDouble* indices=NULL;
    6016         IssmDouble alpha;
    6017         IssmDouble delPhi,delLambda;
    6018 
    60196001        /*optimization:*/
    60206002        bool store_green_functions=false;
     6003       
     6004        rho_water=FindParam(MaterialsRhoSeawaterEnum);
    60216005
    6022         /*ice properties: */
    6023         IssmDouble rho_ice,rho_water,rho_earth;
    6024 
    6025         /*Computational flags:*/
    6026         bool computerigid = true;
    6027         bool computeelastic= true;
    6028 
    60296006        /*early return if we are not on the ocean:*/
    60306007        if (!masks->isoceanin[this->lid]){
    6031                 constant=0; this->AddInput2(SealevelEustaticOceanMaskEnum,&constant,P0Enum);
     6008                constant=0;
     6009                #ifdef _ISSM_DEBUG_
     6010                this->AddInput2(SealevelEustaticOceanMaskEnum,&constant,P0Enum);
     6011                #endif
    60326012                return;
    60336013        }
    6034         constant=1; this->AddInput2(SealevelEustaticOceanMaskEnum,&constant,P0Enum);
     6014        constant=1;
     6015        #ifdef _ISSM_DEBUG_
     6016        this->AddInput2(SealevelEustaticOceanMaskEnum,&constant,P0Enum);
     6017        #endif
    60356018
    6036         /*recover computational flags: */
    6037         this->parameters->FindParam(&computerigid,SealevelriseRigidEnum);
    6038         this->parameters->FindParam(&computeelastic,SealevelriseElasticEnum);
    6039 
    6040         /*recover earth area: */
    6041         this->parameters->FindParam(&eartharea,SealevelEarthAreaEnum);
    6042 
    6043         /*early return if rigid or elastic not requested:*/
    6044         if(!computerigid && !computeelastic) return;
    6045 
    6046         /*recover material parameters: */
    6047         rho_water=FindParam(MaterialsRhoSeawaterEnum);
    6048         rho_earth=FindParam(MaterialsEarthDensityEnum);
    6049 
    60506019        /*how many dofs are we working with here? */
    60516020        this->parameters->FindParam(&gsize,MeshNumberofverticesEnum);
     6021       
     6022        /*retrieve precomputed G:*/
     6023        this->inputs2->GetArrayPtr(SealevelriseGEnum,this->lid,&G,&dummy); _assert_(dummy==gsize);
    60526024
    6053         /*retrieve indices:*/
    6054         if(computerigid){this->inputs2->GetArrayPtr(SealevelriseIndicesEnum,this->lid,&indices,&dummy); _assert_(dummy==gsize);}
    6055 
    60566025        /*From Sg_old, recover water sea level rise:*/
    60576026        S=0; for(int i=0;i<NUMVERTICES;i++) S+=Sg_old[this->vertices[i]->Sid()]/NUMVERTICES;
    60586027
    6059         /*Get area of element: precomputed in the sealevelrise_core_geometry:*/
    6060         this->GetInput2Value(&area,AreaEnum);
     6028        /*convert to SI: */
     6029        S=S*rho_water;
    60616030
    6062         /*recover rigid and elastic green functions:*/
    6063         DoubleVecParam* parameter = static_cast<DoubleVecParam*>(this->parameters->FindParamObject(SealevelriseGRigidEnum)); _assert_(parameter);
    6064         parameter->GetParameterValueByPointer(&G_rigid_precomputed,&M);
     6031        for(int i=0;i<gsize;i++) Sgo[i]+=G[i]*S;
    60656032
    6066         if(computeelastic){
    6067                 /*recover elastic green function:*/
    6068                 parameter = static_cast<DoubleVecParam*>(this->parameters->FindParamObject(SealevelriseGElasticEnum)); _assert_(parameter);
    6069                 parameter->GetParameterValueByPointer(&G_elastic_precomputed,&M);
    6070         }
    6071 
    6072        
    6073         for(int i=0;i<gsize;i++){
    6074 
    6075                 /*Compute alpha angle between centroid and current vertex : */
    6076                 /*lati=latitude[i]/180*PI; longi=longitude[i]/180*PI;
    6077                 delPhi=fabs(lati-late); delLambda=fabs(longi-longe);
    6078                 alpha=2.*asin(sqrt(pow(sin(delPhi/2),2.0)+cos(lati)*cos(late)*pow(sin(delLambda/2),2)));
    6079                 index=reCast<int,IssmDouble>(alpha/PI*(M-1));*/
    6080                        
    6081                 index=reCast<int,IssmDouble>(indices[i]);
    6082 
    6083                 /*Rigid earth gravitational perturbation: */
    6084                 if(computerigid){
    6085                         Sgo[i]+=3*rho_water/rho_earth*area/eartharea*S*G_rigid_precomputed[index];
    6086                 }
    6087 
    6088                 /*Elastic component  (from Eq 17 in Adhikari et al, GMD 2015): */
    6089                 if(computeelastic){
    6090                         Sgo[i]+=3*rho_water/rho_earth*area/eartharea*S*G_elastic_precomputed[index];
    6091                 }
    6092         }
    6093 
    6094 
    60956033        return;
    60966034}
    60976035/*}}}*/

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

     
    681681        SealevelriseSpcthicknessEnum,
    682682        SealevelriseHydroRateEnum,
    683683        SealevelriseIndicesEnum,
     684        SealevelriseGEnum,
    684685        SedimentHeadEnum,
    685686        SedimentHeadOldEnum,
    686687        SedimentHeadSubstepEnum,

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

     
    686686                case SealevelriseSpcthicknessEnum : return "SealevelriseSpcthickness";
    687687                case SealevelriseHydroRateEnum : return "SealevelriseHydroRate";
    688688                case SealevelriseIndicesEnum : return "SealevelriseIndices";
     689                case SealevelriseGEnum : return "SealevelriseG";
    689690                case SedimentHeadEnum : return "SedimentHead";
    690691                case SedimentHeadOldEnum : return "SedimentHeadOld";
    691692                case SedimentHeadSubstepEnum : return "SedimentHeadSubstep";

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

     
    701701              else if (strcmp(name,"SealevelriseSpcthickness")==0) return SealevelriseSpcthicknessEnum;
    702702              else if (strcmp(name,"SealevelriseHydroRate")==0) return SealevelriseHydroRateEnum;
    703703              else if (strcmp(name,"SealevelriseIndices")==0) return SealevelriseIndicesEnum;
     704              else if (strcmp(name,"SealevelriseG")==0) return SealevelriseGEnum;
    704705              else if (strcmp(name,"SedimentHead")==0) return SedimentHeadEnum;
    705706              else if (strcmp(name,"SedimentHeadOld")==0) return SedimentHeadOldEnum;
    706707              else if (strcmp(name,"SedimentHeadSubstep")==0) return SedimentHeadSubstepEnum;
    … …  
    750751              else if (strcmp(name,"SmbHref")==0) return SmbHrefEnum;
    751752              else if (strcmp(name,"SmbIsInitialized")==0) return SmbIsInitializedEnum;
    752753              else if (strcmp(name,"SmbMAdd")==0) return SmbMAddEnum;
    753               else if (strcmp(name,"SmbMassBalanceClimate")==0) return SmbMassBalanceClimateEnum;
    754754         else stage=7;
    755755   }
    756756   if(stage==7){
    757               if (strcmp(name,"SmbMassBalance")==0) return SmbMassBalanceEnum;
     757              if (strcmp(name,"SmbMassBalanceClimate")==0) return SmbMassBalanceClimateEnum;
     758              else if (strcmp(name,"SmbMassBalance")==0) return SmbMassBalanceEnum;
    758759              else if (strcmp(name,"SmbMassBalanceSubstep")==0) return SmbMassBalanceSubstepEnum;
    759760              else if (strcmp(name,"SmbMassBalanceTransient")==0) return SmbMassBalanceTransientEnum;
    760761              else if (strcmp(name,"SmbMeanLHF")==0) return SmbMeanLHFEnum;
    … …  
    873874              else if (strcmp(name,"Outputdefinition1")==0) return Outputdefinition1Enum;
    874875              else if (strcmp(name,"Outputdefinition10")==0) return Outputdefinition10Enum;
    875876              else if (strcmp(name,"Outputdefinition11")==0) return Outputdefinition11Enum;
    876               else if (strcmp(name,"Outputdefinition12")==0) return Outputdefinition12Enum;
    877877         else stage=8;
    878878   }
    879879   if(stage==8){
    880               if (strcmp(name,"Outputdefinition13")==0) return Outputdefinition13Enum;
     880              if (strcmp(name,"Outputdefinition12")==0) return Outputdefinition12Enum;
     881              else if (strcmp(name,"Outputdefinition13")==0) return Outputdefinition13Enum;
    881882              else if (strcmp(name,"Outputdefinition14")==0) return Outputdefinition14Enum;
    882883              else if (strcmp(name,"Outputdefinition15")==0) return Outputdefinition15Enum;
    883884              else if (strcmp(name,"Outputdefinition16")==0) return Outputdefinition16Enum;
    … …  
    996997              else if (strcmp(name,"BalancevelocityAnalysis")==0) return BalancevelocityAnalysisEnum;
    997998              else if (strcmp(name,"BalancevelocitySolution")==0) return BalancevelocitySolutionEnum;
    998999              else if (strcmp(name,"BasalforcingsIsmip6")==0) return BasalforcingsIsmip6Enum;
    999               else if (strcmp(name,"BasalforcingsPico")==0) return BasalforcingsPicoEnum;
    10001000         else stage=9;
    10011001   }
    10021002   if(stage==9){
    1003               if (strcmp(name,"BeckmannGoosseFloatingMeltRate")==0) return BeckmannGoosseFloatingMeltRateEnum;
     1003              if (strcmp(name,"BasalforcingsPico")==0) return BasalforcingsPicoEnum;
     1004              else if (strcmp(name,"BeckmannGoosseFloatingMeltRate")==0) return BeckmannGoosseFloatingMeltRateEnum;
    10041005              else if (strcmp(name,"BedSlopeSolution")==0) return BedSlopeSolutionEnum;
    10051006              else if (strcmp(name,"BoolExternalResult")==0) return BoolExternalResultEnum;
    10061007              else if (strcmp(name,"BoolInput")==0) return BoolInputEnum;
    … …  
    11191120              else if (strcmp(name,"Hydrologypism")==0) return HydrologypismEnum;
    11201121              else if (strcmp(name,"Hydrologyshakti")==0) return HydrologyshaktiEnum;
    11211122              else if (strcmp(name,"Hydrologyshreve")==0) return HydrologyshreveEnum;
    1122               else if (strcmp(name,"IceMass")==0) return IceMassEnum;
    11231123         else stage=10;
    11241124   }
    11251125   if(stage==10){
    1126               if (strcmp(name,"IceMassScaled")==0) return IceMassScaledEnum;
     1126              if (strcmp(name,"IceMass")==0) return IceMassEnum;
     1127              else if (strcmp(name,"IceMassScaled")==0) return IceMassScaledEnum;
    11271128              else if (strcmp(name,"IceVolumeAboveFloatation")==0) return IceVolumeAboveFloatationEnum;
    11281129              else if (strcmp(name,"IceVolumeAboveFloatationScaled")==0) return IceVolumeAboveFloatationScaledEnum;
    11291130              else if (strcmp(name,"IceVolume")==0) return IceVolumeEnum;
    … …  
    12421243              else if (strcmp(name,"P2xP4")==0) return P2xP4Enum;
    12431244              else if (strcmp(name,"Paterson")==0) return PatersonEnum;
    12441245              else if (strcmp(name,"Pengrid")==0) return PengridEnum;
    1245               else if (strcmp(name,"Penpair")==0) return PenpairEnum;
    12461246         else stage=11;
    12471247   }
    12481248   if(stage==11){
    1249               if (strcmp(name,"Penta")==0) return PentaEnum;
     1249              if (strcmp(name,"Penpair")==0) return PenpairEnum;
     1250              else if (strcmp(name,"Penta")==0) return PentaEnum;
    12501251              else if (strcmp(name,"PentaInput")==0) return PentaInputEnum;
    12511252              else if (strcmp(name,"Profiler")==0) return ProfilerEnum;
    12521253              else if (strcmp(name,"ProfilingCurrentFlops")==0) return ProfilingCurrentFlopsEnum;

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

     
    684684syn keyword cConstant SealevelriseSpcthicknessEnum
    685685syn keyword cConstant SealevelriseHydroRateEnum
    686686syn keyword cConstant SealevelriseIndicesEnum
     687syn keyword cConstant SealevelriseGEnum
    687688syn keyword cConstant SedimentHeadEnum
    688689syn keyword cConstant SedimentHeadOldEnum
    689690syn keyword cConstant SedimentHeadSubstepEnum
Note: See TracBrowser for help on using the repository browser.