Index: /issm/trunk-jpl/src/c/classes/Elements/Element.h =================================================================== --- /issm/trunk-jpl/src/c/classes/Elements/Element.h (revision 23992) +++ /issm/trunk-jpl/src/c/classes/Elements/Element.h (revision 23993) @@ -321,5 +321,4 @@ virtual int TensorInterpolation()=0; virtual IssmDouble TimeAdapt()=0; - virtual IssmDouble TotalCalvingFlux(bool scaled){_error_("not implemented");}; virtual IssmDouble TotalCalvingFluxLevelset(bool scaled){_error_("not implemented");}; virtual IssmDouble TotalFloatingBmb(bool scaled)=0; Index: /issm/trunk-jpl/src/c/classes/Elements/Tria.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/Elements/Tria.cpp (revision 23992) +++ /issm/trunk-jpl/src/c/classes/Elements/Tria.cpp (revision 23993) @@ -4060,60 +4060,4 @@ } /*}}}*/ -IssmDouble Tria::TotalCalvingFlux(bool scaled){/*{{{*/ - - /*Make sure there is an ice front here*/ - if(!IsIceInElement() || !IsIcefront()) return 0; - - /*Scaled not implemented yet...*/ - _assert_(!scaled); - - /*Get domain type*/ - int domaintype; - parameters->FindParam(&domaintype,DomainTypeEnum); - - /*Get ice front coordinates*/ - IssmDouble *xyz_list = NULL; - IssmDouble* xyz_front = NULL; - this->GetVerticesCoordinates(&xyz_list); - this->GetIcefrontCoordinates(&xyz_front,xyz_list,MaskIceLevelsetEnum); - - /*Get normal vector*/ - IssmDouble normal[3]; - this->NormalSection(&normal[0],xyz_front); - //normal[0] = -normal[0]; - //normal[1] = -normal[1]; - - /*Get inputs*/ - IssmDouble flux = 0.; - IssmDouble calvingratex,calvingratey,thickness,Jdet; - IssmDouble rho_ice=FindParam(MaterialsRhoIceEnum); - Input* thickness_input=inputs->GetInput(ThicknessEnum); _assert_(thickness_input); - Input* calvingratex_input=NULL; - Input* calvingratey_input=NULL; - if(domaintype==Domain2DhorizontalEnum){ - calvingratex_input=inputs->GetInput(CalvingratexEnum); _assert_(calvingratex_input); - calvingratey_input=inputs->GetInput(CalvingrateyEnum); _assert_(calvingratey_input); - } - else{ - calvingratex_input=inputs->GetInput(CalvingratexAverageEnum); _assert_(calvingratex_input); - calvingratey_input=inputs->GetInput(CalvingrateyAverageEnum); _assert_(calvingratey_input); - } - - /*Start looping on Gaussian points*/ - Gauss* gauss=this->NewGauss(xyz_list,xyz_front,3); - for(int ig=gauss->begin();igend();ig++){ - - gauss->GaussPoint(ig); - thickness_input->GetInputValue(&thickness,gauss); - calvingratex_input->GetInputValue(&calvingratex,gauss); - calvingratey_input->GetInputValue(&calvingratey,gauss); - this->JacobianDeterminantSurface(&Jdet,xyz_front,gauss); - - flux += rho_ice*Jdet*gauss->weight*thickness*(calvingratex*normal[0] + calvingratey*normal[1]); - } - - return flux; -} -/*}}}*/ IssmDouble Tria::TotalCalvingFluxLevelset(bool scaled){/*{{{*/ Index: /issm/trunk-jpl/src/c/classes/Elements/Tria.h =================================================================== --- /issm/trunk-jpl/src/c/classes/Elements/Tria.h (revision 23992) +++ /issm/trunk-jpl/src/c/classes/Elements/Tria.h (revision 23993) @@ -137,5 +137,4 @@ int TensorInterpolation(); IssmDouble TimeAdapt(); - IssmDouble TotalCalvingFlux(bool scaled); IssmDouble TotalCalvingFluxLevelset(bool scaled); IssmDouble TotalFloatingBmb(bool scaled); Index: /issm/trunk-jpl/src/c/classes/FemModel.cpp =================================================================== --- /issm/trunk-jpl/src/c/classes/FemModel.cpp (revision 23992) +++ /issm/trunk-jpl/src/c/classes/FemModel.cpp (revision 23993) @@ -2202,5 +2202,4 @@ case MaxAbsVzEnum: this->MaxAbsVzx(&double_result); break; case MassFluxEnum: this->MassFluxx(&double_result); break; - case TotalCalvingFluxEnum: this->TotalCalvingFluxx(&double_result,false); break; case TotalCalvingFluxLevelsetEnum: this->TotalCalvingFluxLevelsetx(&double_result,false); break; case TotalFloatingBmbEnum: this->TotalFloatingBmbx(&double_result,false); break; @@ -2448,5 +2447,4 @@ case DragCoefficientAbsGradientEnum: DragCoefficientAbsGradientx(responses, elements,nodes, vertices, loads, materials, parameters); break; case BalancethicknessMisfitEnum: BalancethicknessMisfitx(responses); break; - case TotalCalvingFluxEnum: this->TotalCalvingFluxx(responses, false); break; case TotalCalvingFluxLevelsetEnum: this->TotalCalvingFluxLevelsetx(responses, false); break; case TotalFloatingBmbEnum: this->TotalFloatingBmbx(responses, false); break; @@ -2714,20 +2712,4 @@ } /*}}}*/ -void FemModel::TotalCalvingFluxx(IssmDouble* pM, bool scaled){/*{{{*/ - - IssmDouble local_calving_flux = 0; - IssmDouble total_calving_flux; - - for(int i=0;ielements->Size();i++){ - Element* element=xDynamicCast(this->elements->GetObjectByOffset(i)); - local_calving_flux+=element->TotalCalvingFlux(scaled); - } - ISSM_MPI_Reduce(&local_calving_flux,&total_calving_flux,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,0,IssmComm::GetComm() ); - ISSM_MPI_Bcast(&total_calving_flux,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm()); - - /*Assign output pointers: */ - *pM=total_calving_flux; - -}/*}}}*/ void FemModel::TotalCalvingFluxLevelsetx(IssmDouble* pM, bool scaled){/*{{{*/ Index: /issm/trunk-jpl/src/c/classes/FemModel.h =================================================================== --- /issm/trunk-jpl/src/c/classes/FemModel.h (revision 23992) +++ /issm/trunk-jpl/src/c/classes/FemModel.h (revision 23993) @@ -127,5 +127,4 @@ void StressIntensityFactorx(); void RignotMeltParameterizationx(); - void TotalCalvingFluxx(IssmDouble* pFbmb, bool scaled); void TotalCalvingFluxLevelsetx(IssmDouble* pGbmb, bool scaled); void TotalFloatingBmbx(IssmDouble* pFbmb, bool scaled); Index: /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h (revision 23992) +++ /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h (revision 23993) @@ -1208,5 +1208,4 @@ ThermalSolutionEnum, ThicknessErrorEstimatorEnum, - TotalCalvingFluxEnum, TotalCalvingFluxLevelsetEnum, TotalFloatingBmbEnum, Index: /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp (revision 23992) +++ /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp (revision 23993) @@ -17,1243 +17,4 @@ switch(en){ - case ParametersSTARTEnum : return "ParametersSTART"; - case AdolcParamEnum : return "AdolcParam"; - case AmrDeviatoricErrorGroupThresholdEnum : return "AmrDeviatoricErrorGroupThreshold"; - case AmrDeviatoricErrorMaximumEnum : return "AmrDeviatoricErrorMaximum"; - case AmrDeviatoricErrorResolutionEnum : return "AmrDeviatoricErrorResolution"; - case AmrDeviatoricErrorThresholdEnum : return "AmrDeviatoricErrorThreshold"; - case AmrErrEnum : return "AmrErr"; - case AmrFieldEnum : return "AmrField"; - case AmrGradationEnum : return "AmrGradation"; - case AmrGroundingLineDistanceEnum : return "AmrGroundingLineDistance"; - case AmrGroundingLineResolutionEnum : return "AmrGroundingLineResolution"; - case AmrHmaxEnum : return "AmrHmax"; - case AmrHminEnum : return "AmrHmin"; - case AmrIceFrontDistanceEnum : return "AmrIceFrontDistance"; - case AmrIceFrontResolutionEnum : return "AmrIceFrontResolution"; - case AmrKeepMetricEnum : return "AmrKeepMetric"; - case AmrLagEnum : return "AmrLag"; - case AmrLevelMaxEnum : return "AmrLevelMax"; - case AmrRestartEnum : return "AmrRestart"; - case AmrThicknessErrorGroupThresholdEnum : return "AmrThicknessErrorGroupThreshold"; - case AmrThicknessErrorMaximumEnum : return "AmrThicknessErrorMaximum"; - case AmrThicknessErrorResolutionEnum : return "AmrThicknessErrorResolution"; - case AmrThicknessErrorThresholdEnum : return "AmrThicknessErrorThreshold"; - case AmrTypeEnum : return "AmrType"; - case AnalysisCounterEnum : return "AnalysisCounter"; - case AnalysisTypeEnum : return "AnalysisType"; - case AugmentedLagrangianREnum : return "AugmentedLagrangianR"; - case AugmentedLagrangianRholambdaEnum : return "AugmentedLagrangianRholambda"; - case AugmentedLagrangianRhopEnum : return "AugmentedLagrangianRhop"; - case AugmentedLagrangianRlambdaEnum : return "AugmentedLagrangianRlambda"; - case AugmentedLagrangianThetaEnum : return "AugmentedLagrangianTheta"; - case AutodiffCbufsizeEnum : return "AutodiffCbufsize"; - case AutodiffDependentObjectsEnum : return "AutodiffDependentObjects"; - case AutodiffDriverEnum : return "AutodiffDriver"; - case AutodiffFosForwardIndexEnum : return "AutodiffFosForwardIndex"; - case AutodiffFosReverseIndexEnum : return "AutodiffFosReverseIndex"; - case AutodiffFovForwardIndicesEnum : return "AutodiffFovForwardIndices"; - case AutodiffGcTriggerMaxSizeEnum : return "AutodiffGcTriggerMaxSize"; - case AutodiffGcTriggerRatioEnum : return "AutodiffGcTriggerRatio"; - case AutodiffIsautodiffEnum : return "AutodiffIsautodiff"; - case AutodiffLbufsizeEnum : return "AutodiffLbufsize"; - case AutodiffNumDependentsEnum : return "AutodiffNumDependents"; - case AutodiffNumIndependentsEnum : return "AutodiffNumIndependents"; - case AutodiffObufsizeEnum : return "AutodiffObufsize"; - case AutodiffTapeAllocEnum : return "AutodiffTapeAlloc"; - case AutodiffTbufsizeEnum : return "AutodiffTbufsize"; - case AutodiffXpEnum : return "AutodiffXp"; - case BalancethicknessStabilizationEnum : return "BalancethicknessStabilization"; - case BasalforcingsBottomplumedepthEnum : return "BasalforcingsBottomplumedepth"; - case BasalforcingsCrustthicknessEnum : return "BasalforcingsCrustthickness"; - case BasalforcingsDeepwaterElevationEnum : return "BasalforcingsDeepwaterElevation"; - case BasalforcingsDeepwaterMeltingRateEnum : return "BasalforcingsDeepwaterMeltingRate"; - case BasalforcingsDtbgEnum : return "BasalforcingsDtbg"; - case BasalforcingsEnum : return "Basalforcings"; - case BasalforcingsIsmp6AverageTfEnum : return "BasalforcingsIsmp6AverageTf"; - case BasalforcingsIsmp6BasinAreaEnum : return "BasalforcingsIsmp6BasinArea"; - case BasalforcingsIsmp6DeltaTEnum : return "BasalforcingsIsmp6DeltaT"; - case BasalforcingsIsmp6Gamma0Enum : return "BasalforcingsIsmp6Gamma0"; - case BasalforcingsIsmp6IsLocalEnum : return "BasalforcingsIsmp6IsLocal"; - case BasalforcingsIsmp6NumBasinsEnum : return "BasalforcingsIsmp6NumBasins"; - case BasalforcingsIsmp6TfDepthsEnum : return "BasalforcingsIsmp6TfDepths"; - case BasalforcingsLowercrustheatEnum : return "BasalforcingsLowercrustheat"; - case BasalforcingsMantleconductivityEnum : return "BasalforcingsMantleconductivity"; - case BasalforcingsMeltrateFactorEnum : return "BasalforcingsMeltrateFactor"; - case BasalforcingsNusseltEnum : return "BasalforcingsNusselt"; - case BasalforcingsPicoAverageOverturningEnum : return "BasalforcingsPicoAverageOverturning"; - case BasalforcingsPicoAverageSalinityEnum : return "BasalforcingsPicoAverageSalinity"; - case BasalforcingsPicoAverageTemperatureEnum : return "BasalforcingsPicoAverageTemperature"; - case BasalforcingsPicoBoxAreaEnum : return "BasalforcingsPicoBoxArea"; - case BasalforcingsPicoFarOceansalinityEnum : return "BasalforcingsPicoFarOceansalinity"; - case BasalforcingsPicoFarOceantemperatureEnum : return "BasalforcingsPicoFarOceantemperature"; - case BasalforcingsPicoGammaTEnum : return "BasalforcingsPicoGammaT"; - case BasalforcingsPicoIsplumeEnum : return "BasalforcingsPicoIsplume"; - case BasalforcingsPicoMaxboxcountEnum : return "BasalforcingsPicoMaxboxcount"; - case BasalforcingsPicoNumBasinsEnum : return "BasalforcingsPicoNumBasins"; - case BasalforcingsPicoOverturningCoeffEnum : return "BasalforcingsPicoOverturningCoeff"; - case BasalforcingsPlumeradiusEnum : return "BasalforcingsPlumeradius"; - case BasalforcingsPlumexEnum : return "BasalforcingsPlumex"; - case BasalforcingsPlumeyEnum : return "BasalforcingsPlumey"; - case BasalforcingsThresholdThicknessEnum : return "BasalforcingsThresholdThickness"; - case BasalforcingsTopplumedepthEnum : return "BasalforcingsTopplumedepth"; - case BasalforcingsUppercrustheatEnum : return "BasalforcingsUppercrustheat"; - case BasalforcingsUppercrustthicknessEnum : return "BasalforcingsUppercrustthickness"; - case BasalforcingsUpperdepthMeltEnum : return "BasalforcingsUpperdepthMelt"; - case BasalforcingsUpperwaterElevationEnum : return "BasalforcingsUpperwaterElevation"; - case BasalforcingsUpperwaterMeltingRateEnum : return "BasalforcingsUpperwaterMeltingRate"; - case CalvingCrevasseDepthEnum : return "CalvingCrevasseDepth"; - case CalvingHeightAboveFloatationEnum : return "CalvingHeightAboveFloatation"; - case CalvingLawEnum : return "CalvingLaw"; - case CalvingMaxEnum : return "CalvingMax"; - case CalvingMinthicknessEnum : return "CalvingMinthickness"; - case ConfigurationTypeEnum : return "ConfigurationType"; - case ConstantsGEnum : return "ConstantsG"; - case ConstantsReferencetemperatureEnum : return "ConstantsReferencetemperature"; - case ConstantsYtsEnum : return "ConstantsYts"; - case ControlInputSizeMEnum : return "ControlInputSizeM"; - case ControlInputSizeNEnum : return "ControlInputSizeN"; - case DamageC1Enum : return "DamageC1"; - case DamageC2Enum : return "DamageC2"; - case DamageC3Enum : return "DamageC3"; - case DamageEnum : return "Damage"; - case DamageEquivStressEnum : return "DamageEquivStress"; - case DamageEvolutionNumRequestedOutputsEnum : return "DamageEvolutionNumRequestedOutputs"; - case DamageEvolutionRequestedOutputsEnum : return "DamageEvolutionRequestedOutputs"; - case DamageHealingEnum : return "DamageHealing"; - case DamageKappaEnum : return "DamageKappa"; - case DamageLawEnum : return "DamageLaw"; - case DamageMaxDamageEnum : return "DamageMaxDamage"; - case DamageStabilizationEnum : return "DamageStabilization"; - case DamageStressThresholdEnum : return "DamageStressThreshold"; - case DebugProfilingEnum : return "DebugProfiling"; - case DomainDimensionEnum : return "DomainDimension"; - case DomainTypeEnum : return "DomainType"; - case EarthIdEnum : return "EarthId"; - case EplZigZagCounterEnum : return "EplZigZagCounter"; - case EsaHElasticEnum : return "EsaHElastic"; - case EsaHemisphereEnum : return "EsaHemisphere"; - case EsaRequestedOutputsEnum : return "EsaRequestedOutputs"; - case EsaUElasticEnum : return "EsaUElastic"; - case ExtrapolationVariableEnum : return "ExtrapolationVariable"; - case FemModelCommEnum : return "FemModelComm"; - case FlowequationFeFSEnum : return "FlowequationFeFS"; - case FlowequationIsFSEnum : return "FlowequationIsFS"; - case FlowequationIsHOEnum : return "FlowequationIsHO"; - case FlowequationIsL1L2Enum : return "FlowequationIsL1L2"; - case FlowequationIsSIAEnum : return "FlowequationIsSIA"; - case FlowequationIsSSAEnum : return "FlowequationIsSSA"; - case FrictionCouplingEnum : return "FrictionCoupling"; - case FrictionDeltaEnum : return "FrictionDelta"; - case FrictionFEnum : return "FrictionF"; - case FrictionGammaEnum : return "FrictionGamma"; - case FrictionLawEnum : return "FrictionLaw"; - case FrictionPseudoplasticityExponentEnum : return "FrictionPseudoplasticityExponent"; - case FrictionThresholdSpeedEnum : return "FrictionThresholdSpeed"; - case FrictionVoidRatioEnum : return "FrictionVoidRatio"; - case FrontalForcingsBasinIcefrontAreaEnum : return "FrontalForcingsBasinIcefrontArea"; - case FrontalForcingsNumberofBasinsEnum : return "FrontalForcingsNumberofBasins"; - case FrontalForcingsParamEnum : return "FrontalForcingsParam"; - case GiaCrossSectionShapeEnum : return "GiaCrossSectionShape"; - case GroundinglineFrictionInterpolationEnum : return "GroundinglineFrictionInterpolation"; - case GroundinglineMeltInterpolationEnum : return "GroundinglineMeltInterpolation"; - case GroundinglineMigrationEnum : return "GroundinglineMigration"; - case HydrologyCavitySpacingEnum : return "HydrologyCavitySpacing"; - case HydrologyChannelConductivityEnum : return "HydrologyChannelConductivity"; - case HydrologyChannelSheetWidthEnum : return "HydrologyChannelSheetWidth"; - case HydrologyEnglacialVoidRatioEnum : return "HydrologyEnglacialVoidRatio"; - case HydrologyIschannelsEnum : return "HydrologyIschannels"; - case HydrologyModelEnum : return "HydrologyModel"; - case HydrologyNumRequestedOutputsEnum : return "HydrologyNumRequestedOutputs"; - case HydrologyPressureMeltCoefficientEnum : return "HydrologyPressureMeltCoefficient"; - case HydrologyRelaxationEnum : return "HydrologyRelaxation"; - case HydrologyRequestedOutputsEnum : return "HydrologyRequestedOutputs"; - case HydrologySedimentKmaxEnum : return "HydrologySedimentKmax"; - case HydrologyStepsPerStepEnum : return "HydrologyStepsPerStep"; - case HydrologyStorageEnum : return "HydrologyStorage"; - case HydrologydcEplColapseThicknessEnum : return "HydrologydcEplColapseThickness"; - case HydrologydcEplCompressibilityEnum : return "HydrologydcEplCompressibility"; - case HydrologydcEplConductivityEnum : return "HydrologydcEplConductivity"; - case HydrologydcEplInitialThicknessEnum : return "HydrologydcEplInitialThickness"; - case HydrologydcEplMaxThicknessEnum : return "HydrologydcEplMaxThickness"; - case HydrologydcEplPorosityEnum : return "HydrologydcEplPorosity"; - case HydrologydcEplThickCompEnum : return "HydrologydcEplThickComp"; - case HydrologydcEplflipLockEnum : return "HydrologydcEplflipLock"; - case HydrologydcIsefficientlayerEnum : return "HydrologydcIsefficientlayer"; - case HydrologydcLeakageFactorEnum : return "HydrologydcLeakageFactor"; - case HydrologydcMaxIterEnum : return "HydrologydcMaxIter"; - case HydrologydcPenaltyFactorEnum : return "HydrologydcPenaltyFactor"; - case HydrologydcPenaltyLockEnum : return "HydrologydcPenaltyLock"; - case HydrologydcRelTolEnum : return "HydrologydcRelTol"; - case HydrologydcSedimentCompressibilityEnum : return "HydrologydcSedimentCompressibility"; - case HydrologydcSedimentPorosityEnum : return "HydrologydcSedimentPorosity"; - case HydrologydcSedimentThicknessEnum : return "HydrologydcSedimentThickness"; - case HydrologydcSedimentlimitEnum : return "HydrologydcSedimentlimit"; - case HydrologydcSedimentlimitFlagEnum : return "HydrologydcSedimentlimitFlag"; - case HydrologydcTransferFlagEnum : return "HydrologydcTransferFlag"; - case HydrologydcUnconfinedFlagEnum : return "HydrologydcUnconfinedFlag"; - case HydrologydcWaterCompressibilityEnum : return "HydrologydcWaterCompressibility"; - case HydrologydtEnum : return "Hydrologydt"; - case HydrologyshreveStabilizationEnum : return "HydrologyshreveStabilization"; - case IcecapToEarthCommEnum : return "IcecapToEarthComm"; - case IndexEnum : return "Index"; - case InputFileNameEnum : return "InputFileName"; - case InputToDepthaverageInEnum : return "InputToDepthaverageIn"; - case InputToDepthaverageOutEnum : return "InputToDepthaverageOut"; - case InputToExtrudeEnum : return "InputToExtrude"; - case InputToL2ProjectEnum : return "InputToL2Project"; - case InputToSmoothEnum : return "InputToSmooth"; - case InversionAlgorithmEnum : return "InversionAlgorithm"; - case InversionControlParametersEnum : return "InversionControlParameters"; - case InversionControlScalingFactorsEnum : return "InversionControlScalingFactors"; - case InversionCostFunctionsEnum : return "InversionCostFunctions"; - case InversionDxminEnum : return "InversionDxmin"; - case InversionGatolEnum : return "InversionGatol"; - case InversionGradientScalingEnum : return "InversionGradientScaling"; - case InversionGrtolEnum : return "InversionGrtol"; - case InversionGttolEnum : return "InversionGttol"; - case InversionIncompleteAdjointEnum : return "InversionIncompleteAdjoint"; - case InversionIscontrolEnum : return "InversionIscontrol"; - case InversionMaxiterEnum : return "InversionMaxiter"; - case InversionMaxiterPerStepEnum : return "InversionMaxiterPerStep"; - case InversionMaxstepsEnum : return "InversionMaxsteps"; - case InversionNstepsEnum : return "InversionNsteps"; - case InversionNumControlParametersEnum : return "InversionNumControlParameters"; - case InversionNumCostFunctionsEnum : return "InversionNumCostFunctions"; - case InversionStepThresholdEnum : return "InversionStepThreshold"; - case InversionTypeEnum : return "InversionType"; - case LevelsetReinitFrequencyEnum : return "LevelsetReinitFrequency"; - case LevelsetStabilizationEnum : return "LevelsetStabilization"; - case LockFileNameEnum : return "LockFileName"; - case LoveAllowLayerDeletionEnum : return "LoveAllowLayerDeletion"; - case LoveForcingTypeEnum : return "LoveForcingType"; - case LoveFrequenciesEnum : return "LoveFrequencies"; - case LoveG0Enum : return "LoveG0"; - case LoveKernelsEnum : return "LoveKernels"; - case LoveMu0Enum : return "LoveMu0"; - case LoveNfreqEnum : return "LoveNfreq"; - case LoveR0Enum : return "LoveR0"; - case LoveShNmaxEnum : return "LoveShNmax"; - case LoveShNminEnum : return "LoveShNmin"; - case MassFluxSegmentsEnum : return "MassFluxSegments"; - case MassFluxSegmentsPresentEnum : return "MassFluxSegmentsPresent"; - case MasstransportHydrostaticAdjustmentEnum : return "MasstransportHydrostaticAdjustment"; - case MasstransportIsfreesurfaceEnum : return "MasstransportIsfreesurface"; - case MasstransportMinThicknessEnum : return "MasstransportMinThickness"; - case MasstransportNumRequestedOutputsEnum : return "MasstransportNumRequestedOutputs"; - case MasstransportPenaltyFactorEnum : return "MasstransportPenaltyFactor"; - case MasstransportRequestedOutputsEnum : return "MasstransportRequestedOutputs"; - case MasstransportStabilizationEnum : return "MasstransportStabilization"; - case MaterialsBetaEnum : return "MaterialsBeta"; - case MaterialsEarthDensityEnum : return "MaterialsEarthDensity"; - case MaterialsEffectiveconductivityAveragingEnum : return "MaterialsEffectiveconductivityAveraging"; - case MaterialsHeatcapacityEnum : return "MaterialsHeatcapacity"; - case MaterialsLatentheatEnum : return "MaterialsLatentheat"; - case MaterialsLithosphereDensityEnum : return "MaterialsLithosphereDensity"; - case MaterialsLithosphereShearModulusEnum : return "MaterialsLithosphereShearModulus"; - case MaterialsMantleDensityEnum : return "MaterialsMantleDensity"; - case MaterialsMantleShearModulusEnum : return "MaterialsMantleShearModulus"; - case MaterialsMeltingpointEnum : return "MaterialsMeltingpoint"; - case MaterialsMixedLayerCapacityEnum : return "MaterialsMixedLayerCapacity"; - case MaterialsMuWaterEnum : return "MaterialsMuWater"; - case MaterialsRheologyLawEnum : return "MaterialsRheologyLaw"; - case MaterialsRhoFreshwaterEnum : return "MaterialsRhoFreshwater"; - case MaterialsRhoIceEnum : return "MaterialsRhoIce"; - case MaterialsRhoSeawaterEnum : return "MaterialsRhoSeawater"; - case MaterialsTemperateiceconductivityEnum : return "MaterialsTemperateiceconductivity"; - case MaterialsThermalExchangeVelocityEnum : return "MaterialsThermalExchangeVelocity"; - case MaterialsThermalconductivityEnum : return "MaterialsThermalconductivity"; - case MeltingOffsetEnum : return "MeltingOffset"; - case MeshAverageVertexConnectivityEnum : return "MeshAverageVertexConnectivity"; - case MeshElementtypeEnum : return "MeshElementtype"; - case MeshNumberoflayersEnum : return "MeshNumberoflayers"; - case MeshNumberofverticesEnum : return "MeshNumberofvertices"; - case ModelIdEnum : return "ModelId"; - case NodesEnum : return "Nodes"; - case NumModelsEnum : return "NumModels"; - case OceanGridNxEnum : return "OceanGridNx"; - case OceanGridNyEnum : return "OceanGridNy"; - case OceanGridXEnum : return "OceanGridX"; - case OceanGridYEnum : return "OceanGridY"; - case OutputBufferPointerEnum : return "OutputBufferPointer"; - case OutputBufferSizePointerEnum : return "OutputBufferSizePointer"; - case OutputFileNameEnum : return "OutputFileName"; - case OutputFilePointerEnum : return "OutputFilePointer"; - case OutputdefinitionEnum : return "Outputdefinition"; - case ParamEnum : return "Param"; - case ParametersEnum : return "Parameters"; - case QmuErrNameEnum : return "QmuErrName"; - case QmuInNameEnum : return "QmuInName"; - case QmuIsdakotaEnum : return "QmuIsdakota"; - case QmuNumberofpartitionsEnum : return "QmuNumberofpartitions"; - case QmuOutNameEnum : return "QmuOutName"; - case QmuPartitionEnum : return "QmuPartition"; - case QmuResponsedescriptorsEnum : return "QmuResponsedescriptors"; - case QmuVariableDescriptorsEnum : return "QmuVariableDescriptors"; - case RestartFileNameEnum : return "RestartFileName"; - case ResultsEnum : return "Results"; - case RootPathEnum : return "RootPath"; - case SaveResultsEnum : return "SaveResults"; - case SealevelEustaticEnum : return "SealevelEustatic"; - case SealevelriseAbstolEnum : return "SealevelriseAbstol"; - case SealevelriseAngularVelocityEnum : return "SealevelriseAngularVelocity"; - case SealevelriseElasticEnum : return "SealevelriseElastic"; - case SealevelriseEquatorialMoiEnum : return "SealevelriseEquatorialMoi"; - case SealevelriseFluidLoveEnum : return "SealevelriseFluidLove"; - case SealevelriseGElasticEnum : return "SealevelriseGElastic"; - case SealevelriseGeodeticEnum : return "SealevelriseGeodetic"; - case SealevelriseGeodeticRunFrequencyEnum : return "SealevelriseGeodeticRunFrequency"; - case SealevelriseHElasticEnum : return "SealevelriseHElastic"; - case SealevelriseHorizEnum : return "SealevelriseHoriz"; - case SealevelriseLoopIncrementEnum : return "SealevelriseLoopIncrement"; - case SealevelriseMaxiterEnum : return "SealevelriseMaxiter"; - case SealevelriseOceanAreaScalingEnum : return "SealevelriseOceanAreaScaling"; - case SealevelrisePolarMoiEnum : return "SealevelrisePolarMoi"; - case SealevelriseReltolEnum : return "SealevelriseReltol"; - case SealevelriseRequestedOutputsEnum : return "SealevelriseRequestedOutputs"; - case SealevelriseRigidEnum : return "SealevelriseRigid"; - case SealevelriseRotationEnum : return "SealevelriseRotation"; - case SealevelriseRunCountEnum : return "SealevelriseRunCount"; - case SealevelriseTidalLoveHEnum : return "SealevelriseTidalLoveH"; - case SealevelriseTidalLoveKEnum : return "SealevelriseTidalLoveK"; - case SealevelriseTransitionsEnum : return "SealevelriseTransitions"; - case SealevelriseUElasticEnum : return "SealevelriseUElastic"; - case SettingsIoGatherEnum : return "SettingsIoGather"; - case SettingsNumResultsOnNodesEnum : return "SettingsNumResultsOnNodes"; - case SettingsOutputFrequencyEnum : return "SettingsOutputFrequency"; - case SettingsRecordingFrequencyEnum : return "SettingsRecordingFrequency"; - case SettingsResultsOnNodesEnum : return "SettingsResultsOnNodes"; - case SettingsSbCouplingFrequencyEnum : return "SettingsSbCouplingFrequency"; - case SettingsSolverResidueThresholdEnum : return "SettingsSolverResidueThreshold"; - case SettingsWaitonlockEnum : return "SettingsWaitonlock"; - case SmbAIceEnum : return "SmbAIce"; - case SmbAIdxEnum : return "SmbAIdx"; - case SmbASnowEnum : return "SmbASnow"; - case SmbAccualtiEnum : return "SmbAccualti"; - case SmbAccugradEnum : return "SmbAccugrad"; - case SmbAccurefEnum : return "SmbAccuref"; - case SmbAdThreshEnum : return "SmbAdThresh"; - case SmbCldFracEnum : return "SmbCldFrac"; - case SmbDelta18oEnum : return "SmbDelta18o"; - case SmbDelta18oSurfaceEnum : return "SmbDelta18oSurface"; - case SmbDenIdxEnum : return "SmbDenIdx"; - case SmbDesfacEnum : return "SmbDesfac"; - case SmbDpermilEnum : return "SmbDpermil"; - case SmbDsnowIdxEnum : return "SmbDsnowIdx"; - case SmbDtEnum : return "SmbDt"; - case SmbEnum : return "Smb"; - case SmbFEnum : return "SmbF"; - case SmbInitDensityScalingEnum : return "SmbInitDensityScaling"; - case SmbIsaccumulationEnum : return "SmbIsaccumulation"; - case SmbIsalbedoEnum : return "SmbIsalbedo"; - case SmbIsclimatologyEnum : return "SmbIsclimatology"; - case SmbIsd18opdEnum : return "SmbIsd18opd"; - case SmbIsdelta18oEnum : return "SmbIsdelta18o"; - case SmbIsdensificationEnum : return "SmbIsdensification"; - case SmbIsfirnwarmingEnum : return "SmbIsfirnwarming"; - case SmbIsgraingrowthEnum : return "SmbIsgraingrowth"; - case SmbIsmeltEnum : return "SmbIsmelt"; - case SmbIsmungsmEnum : return "SmbIsmungsm"; - case SmbIsprecipscaledEnum : return "SmbIsprecipscaled"; - case SmbIssetpddfacEnum : return "SmbIssetpddfac"; - case SmbIsshortwaveEnum : return "SmbIsshortwave"; - case SmbIstemperaturescaledEnum : return "SmbIstemperaturescaled"; - case SmbIsthermalEnum : return "SmbIsthermal"; - case SmbIsturbulentfluxEnum : return "SmbIsturbulentflux"; - case SmbKEnum : return "SmbK"; - case SmbNumRequestedOutputsEnum : return "SmbNumRequestedOutputs"; - case SmbPfacEnum : return "SmbPfac"; - case SmbRdlEnum : return "SmbRdl"; - case SmbRequestedOutputsEnum : return "SmbRequestedOutputs"; - case SmbRlapsEnum : return "SmbRlaps"; - case SmbRlapslgmEnum : return "SmbRlapslgm"; - case SmbRunoffaltiEnum : return "SmbRunoffalti"; - case SmbRunoffgradEnum : return "SmbRunoffgrad"; - case SmbRunoffrefEnum : return "SmbRunoffref"; - case SmbSealevEnum : return "SmbSealev"; - case SmbSwIdxEnum : return "SmbSwIdx"; - case SmbT0dryEnum : return "SmbT0dry"; - case SmbT0wetEnum : return "SmbT0wet"; - case SmbTdiffEnum : return "SmbTdiff"; - case SmbThermoDeltaTScalingEnum : return "SmbThermoDeltaTScaling"; - case SmoothThicknessMultiplierEnum : return "SmoothThicknessMultiplier"; - case SolutionTypeEnum : return "SolutionType"; - case SteadystateMaxiterEnum : return "SteadystateMaxiter"; - case SteadystateNumRequestedOutputsEnum : return "SteadystateNumRequestedOutputs"; - case SteadystateReltolEnum : return "SteadystateReltol"; - case SteadystateRequestedOutputsEnum : return "SteadystateRequestedOutputs"; - case StepEnum : return "Step"; - case StressbalanceAbstolEnum : return "StressbalanceAbstol"; - case StressbalanceFSreconditioningEnum : return "StressbalanceFSreconditioning"; - case StressbalanceIsnewtonEnum : return "StressbalanceIsnewton"; - case StressbalanceMaxiterEnum : return "StressbalanceMaxiter"; - case StressbalanceNumRequestedOutputsEnum : return "StressbalanceNumRequestedOutputs"; - case StressbalancePenaltyFactorEnum : return "StressbalancePenaltyFactor"; - case StressbalanceReltolEnum : return "StressbalanceReltol"; - case StressbalanceRequestedOutputsEnum : return "StressbalanceRequestedOutputs"; - case StressbalanceRestolEnum : return "StressbalanceRestol"; - case StressbalanceRiftPenaltyThresholdEnum : return "StressbalanceRiftPenaltyThreshold"; - case StressbalanceShelfDampeningEnum : return "StressbalanceShelfDampening"; - case ThermalIsdynamicbasalspcEnum : return "ThermalIsdynamicbasalspc"; - case ThermalIsenthalpyEnum : return "ThermalIsenthalpy"; - case ThermalMaxiterEnum : return "ThermalMaxiter"; - case ThermalNumRequestedOutputsEnum : return "ThermalNumRequestedOutputs"; - case ThermalPenaltyFactorEnum : return "ThermalPenaltyFactor"; - case ThermalPenaltyLockEnum : return "ThermalPenaltyLock"; - case ThermalPenaltyThresholdEnum : return "ThermalPenaltyThreshold"; - case ThermalReltolEnum : return "ThermalReltol"; - case ThermalRequestedOutputsEnum : return "ThermalRequestedOutputs"; - case ThermalStabilizationEnum : return "ThermalStabilization"; - case TimeEnum : return "Time"; - case TimesteppingCflCoefficientEnum : return "TimesteppingCflCoefficient"; - case TimesteppingCouplingTimeEnum : return "TimesteppingCouplingTime"; - case TimesteppingFinalTimeEnum : return "TimesteppingFinalTime"; - case TimesteppingInterpForcingsEnum : return "TimesteppingInterpForcings"; - case TimesteppingStartTimeEnum : return "TimesteppingStartTime"; - case TimesteppingTimeStepEnum : return "TimesteppingTimeStep"; - case TimesteppingTimeStepMaxEnum : return "TimesteppingTimeStepMax"; - case TimesteppingTimeStepMinEnum : return "TimesteppingTimeStepMin"; - case TimesteppingTypeEnum : return "TimesteppingType"; - case ToMITgcmCommEnum : return "ToMITgcmComm"; - case ToolkitsFileNameEnum : return "ToolkitsFileName"; - case ToolkitsOptionsAnalysesEnum : return "ToolkitsOptionsAnalyses"; - case ToolkitsOptionsStringsEnum : return "ToolkitsOptionsStrings"; - case ToolkitsTypesEnum : return "ToolkitsTypes"; - case TransientAmrFrequencyEnum : return "TransientAmrFrequency"; - case TransientIscouplerEnum : return "TransientIscoupler"; - case TransientIsdamageevolutionEnum : return "TransientIsdamageevolution"; - case TransientIsesaEnum : return "TransientIsesa"; - case TransientIsgiaEnum : return "TransientIsgia"; - case TransientIsgroundinglineEnum : return "TransientIsgroundingline"; - case TransientIshydrologyEnum : return "TransientIshydrology"; - case TransientIsmasstransportEnum : return "TransientIsmasstransport"; - case TransientIsmovingfrontEnum : return "TransientIsmovingfront"; - case TransientIsoceancouplingEnum : return "TransientIsoceancoupling"; - case TransientIsslrEnum : return "TransientIsslr"; - case TransientIssmbEnum : return "TransientIssmb"; - case TransientIsstressbalanceEnum : return "TransientIsstressbalance"; - case TransientIsthermalEnum : return "TransientIsthermal"; - case TransientNumRequestedOutputsEnum : return "TransientNumRequestedOutputs"; - case TransientRequestedOutputsEnum : return "TransientRequestedOutputs"; - case VelocityEnum : return "Velocity"; - case WorldCommEnum : return "WorldComm"; - case ParametersENDEnum : return "ParametersEND"; - case InputsSTARTEnum : return "InputsSTART"; - case AdjointEnum : return "Adjoint"; - case AdjointpEnum : return "Adjointp"; - case AdjointxEnum : return "Adjointx"; - case AdjointyEnum : return "Adjointy"; - case AdjointzEnum : return "Adjointz"; - case AirEnum : return "Air"; - case ApproximationEnum : return "Approximation"; - case BalancethicknessMisfitEnum : return "BalancethicknessMisfit"; - case BalancethicknessOmega0Enum : return "BalancethicknessOmega0"; - case BalancethicknessOmegaEnum : return "BalancethicknessOmega"; - case BalancethicknessThickeningRateEnum : return "BalancethicknessThickeningRate"; - case BasalCrevasseEnum : return "BasalCrevasse"; - case BasalforcingsFloatingiceMeltingRateEnum : return "BasalforcingsFloatingiceMeltingRate"; - case BasalforcingsGeothermalfluxEnum : return "BasalforcingsGeothermalflux"; - case BasalforcingsGroundediceMeltingRateEnum : return "BasalforcingsGroundediceMeltingRate"; - case BasalforcingsIsmp6BasinIdEnum : return "BasalforcingsIsmp6BasinId"; - case BasalforcingsIsmp6TfEnum : return "BasalforcingsIsmp6Tf"; - case BasalforcingsIsmp6TfShelfEnum : return "BasalforcingsIsmp6TfShelf"; - case BasalforcingsPicoBasinIdEnum : return "BasalforcingsPicoBasinId"; - case BasalforcingsPicoBoxIdEnum : return "BasalforcingsPicoBoxId"; - case BasalforcingsPicoSubShelfOceanOverturningEnum : return "BasalforcingsPicoSubShelfOceanOverturning"; - case BasalforcingsPicoSubShelfOceanSalinityEnum : return "BasalforcingsPicoSubShelfOceanSalinity"; - case BasalforcingsPicoSubShelfOceanTempEnum : return "BasalforcingsPicoSubShelfOceanTemp"; - case BaseEnum : return "Base"; - case BaseSlopeXEnum : return "BaseSlopeX"; - case BaseSlopeYEnum : return "BaseSlopeY"; - case BedEnum : return "Bed"; - case BedSlopeXEnum : return "BedSlopeX"; - case BedSlopeYEnum : return "BedSlopeY"; - case CalvingCalvingrateEnum : return "CalvingCalvingrate"; - case CalvingHabFractionEnum : return "CalvingHabFraction"; - case CalvingMeltingrateEnum : return "CalvingMeltingrate"; - case CalvingStressThresholdFloatingiceEnum : return "CalvingStressThresholdFloatingice"; - case CalvingStressThresholdGroundediceEnum : return "CalvingStressThresholdGroundedice"; - case CalvinglevermannCoeffEnum : return "CalvinglevermannCoeff"; - case CalvingratexAverageEnum : return "CalvingratexAverage"; - case CalvingratexEnum : return "Calvingratex"; - case CalvingrateyAverageEnum : return "CalvingrateyAverage"; - case CalvingrateyEnum : return "Calvingratey"; - case ConvergedEnum : return "Converged"; - case CrevasseDepthEnum : return "CrevasseDepth"; - case DamageDEnum : return "DamageD"; - case DamageDbarEnum : return "DamageDbar"; - case DamageFEnum : return "DamageF"; - case DegreeOfChannelizationEnum : return "DegreeOfChannelization"; - case DeviatoricStresseffectiveEnum : return "DeviatoricStresseffective"; - case DeviatoricStressxxEnum : return "DeviatoricStressxx"; - case DeviatoricStressxyEnum : return "DeviatoricStressxy"; - case DeviatoricStressxzEnum : return "DeviatoricStressxz"; - case DeviatoricStressyyEnum : return "DeviatoricStressyy"; - case DeviatoricStressyzEnum : return "DeviatoricStressyz"; - case DeviatoricStresszzEnum : return "DeviatoricStresszz"; - case DistanceToCalvingfrontEnum : return "DistanceToCalvingfront"; - case DistanceToGroundinglineEnum : return "DistanceToGroundingline"; - case Domain2DhorizontalEnum : return "Domain2Dhorizontal"; - case Domain2DverticalEnum : return "Domain2Dvertical"; - case Domain3DEnum : return "Domain3D"; - case DragCoefficientAbsGradientEnum : return "DragCoefficientAbsGradient"; - case DrivingStressXEnum : return "DrivingStressX"; - case DrivingStressYEnum : return "DrivingStressY"; - case EffectivePressureEnum : return "EffectivePressure"; - case EffectivePressureHydrostepEnum : return "EffectivePressureHydrostep"; - case EffectivePressureStackedEnum : return "EffectivePressureStacked"; - case EnthalpyEnum : return "Enthalpy"; - case EnthalpyPicardEnum : return "EnthalpyPicard"; - case EplHeadEnum : return "EplHead"; - case EplHeadHydrostepEnum : return "EplHeadHydrostep"; - case EplHeadOldEnum : return "EplHeadOld"; - case EplHeadSlopeXEnum : return "EplHeadSlopeX"; - case EplHeadSlopeYEnum : return "EplHeadSlopeY"; - case EplHeadStackedEnum : return "EplHeadStacked"; - case EsaDeltathicknessEnum : return "EsaDeltathickness"; - case EsaEmotionEnum : return "EsaEmotion"; - case EsaNmotionEnum : return "EsaNmotion"; - case EsaRotationrateEnum : return "EsaRotationrate"; - case EsaStrainratexxEnum : return "EsaStrainratexx"; - case EsaStrainratexyEnum : return "EsaStrainratexy"; - case EsaStrainrateyyEnum : return "EsaStrainrateyy"; - case EsaUmotionEnum : return "EsaUmotion"; - case EsaXmotionEnum : return "EsaXmotion"; - case EsaYmotionEnum : return "EsaYmotion"; - case EtaDiffEnum : return "EtaDiff"; - case FlowequationBorderFSEnum : return "FlowequationBorderFS"; - case FrictionAsEnum : return "FrictionAs"; - case FrictionCEnum : return "FrictionC"; - case FrictionCmaxEnum : return "FrictionCmax"; - case FrictionCoefficientEnum : return "FrictionCoefficient"; - case FrictionCoefficientcoulombEnum : return "FrictionCoefficientcoulomb"; - case FrictionEffectivePressureEnum : return "FrictionEffectivePressure"; - case FrictionMEnum : return "FrictionM"; - case FrictionPEnum : return "FrictionP"; - case FrictionPressureAdjustedTemperatureEnum : return "FrictionPressureAdjustedTemperature"; - case FrictionQEnum : return "FrictionQ"; - case FrictionSedimentCompressibilityCoefficientEnum : return "FrictionSedimentCompressibilityCoefficient"; - case FrictionTillFrictionAngleEnum : return "FrictionTillFrictionAngle"; - case FrictionWaterLayerEnum : return "FrictionWaterLayer"; - case FrictionfEnum : return "Frictionf"; - case FrontalForcingsBasinIdEnum : return "FrontalForcingsBasinId"; - case FrontalForcingsSubglacialDischargeEnum : return "FrontalForcingsSubglacialDischarge"; - case FrontalForcingsThermalForcingEnum : return "FrontalForcingsThermalForcing"; - case GeometryHydrostaticRatioEnum : return "GeometryHydrostaticRatio"; - case GiaLithosphereThicknessEnum : return "GiaLithosphereThickness"; - case GiaMantleViscosityEnum : return "GiaMantleViscosity"; - case GiaWEnum : return "GiaW"; - case GiadWdtEnum : return "GiadWdt"; - case GradientEnum : return "Gradient"; - case GroundinglineHeightEnum : return "GroundinglineHeight"; - case HydraulicPotentialEnum : return "HydraulicPotential"; - case HydraulicPotentialOldEnum : return "HydraulicPotentialOld"; - case HydrologyBasalFluxEnum : return "HydrologyBasalFlux"; - case HydrologyBumpHeightEnum : return "HydrologyBumpHeight"; - case HydrologyBumpSpacingEnum : return "HydrologyBumpSpacing"; - case HydrologyDrainageRateEnum : return "HydrologyDrainageRate"; - case HydrologyEnglacialInputEnum : return "HydrologyEnglacialInput"; - case HydrologyGapHeightEnum : return "HydrologyGapHeight"; - case HydrologyHeadEnum : return "HydrologyHead"; - case HydrologyHeadOldEnum : return "HydrologyHeadOld"; - case HydrologyMoulinInputEnum : return "HydrologyMoulinInput"; - case HydrologyNeumannfluxEnum : return "HydrologyNeumannflux"; - case HydrologyReynoldsEnum : return "HydrologyReynolds"; - case HydrologySheetConductivityEnum : return "HydrologySheetConductivity"; - case HydrologySheetThicknessEnum : return "HydrologySheetThickness"; - case HydrologyWaterVxEnum : return "HydrologyWaterVx"; - case HydrologyWaterVyEnum : return "HydrologyWaterVy"; - case HydrologyWatercolumnMaxEnum : return "HydrologyWatercolumnMax"; - case HydrologydcBasalMoulinInputEnum : return "HydrologydcBasalMoulinInput"; - case HydrologydcEplThicknessEnum : return "HydrologydcEplThickness"; - case HydrologydcEplThicknessHydrostepEnum : return "HydrologydcEplThicknessHydrostep"; - case HydrologydcEplThicknessOldEnum : return "HydrologydcEplThicknessOld"; - case HydrologydcEplThicknessStackedEnum : return "HydrologydcEplThicknessStacked"; - case HydrologydcMaskEplactiveEltEnum : return "HydrologydcMaskEplactiveElt"; - case HydrologydcMaskEplactiveNodeEnum : return "HydrologydcMaskEplactiveNode"; - case HydrologydcMaskThawedEltEnum : return "HydrologydcMaskThawedElt"; - case HydrologydcMaskThawedNodeEnum : return "HydrologydcMaskThawedNode"; - case HydrologydcSedimentTransmitivityEnum : return "HydrologydcSedimentTransmitivity"; - case IceEnum : return "Ice"; - case IceMaskNodeActivationEnum : return "IceMaskNodeActivation"; - case InputEnum : return "Input"; - case InversionCostFunctionsCoefficientsEnum : return "InversionCostFunctionsCoefficients"; - case InversionSurfaceObsEnum : return "InversionSurfaceObs"; - case InversionThicknessObsEnum : return "InversionThicknessObs"; - case InversionVelObsEnum : return "InversionVelObs"; - case InversionVxObsEnum : return "InversionVxObs"; - case InversionVyObsEnum : return "InversionVyObs"; - case LevelsetfunctionSlopeXEnum : return "LevelsetfunctionSlopeX"; - case LevelsetfunctionSlopeYEnum : return "LevelsetfunctionSlopeY"; - case LoadingforceXEnum : return "LoadingforceX"; - case LoadingforceYEnum : return "LoadingforceY"; - case LoadingforceZEnum : return "LoadingforceZ"; - case MaskGroundediceLevelsetEnum : return "MaskGroundediceLevelset"; - case MaskIceLevelsetEnum : return "MaskIceLevelset"; - case MaskLandLevelsetEnum : return "MaskLandLevelset"; - case MaskOceanLevelsetEnum : return "MaskOceanLevelset"; - case MasstransportSpcthicknessEnum : return "MasstransportSpcthickness"; - case MaterialsRheologyBEnum : return "MaterialsRheologyB"; - case MaterialsRheologyBbarEnum : return "MaterialsRheologyBbar"; - case MaterialsRheologyEEnum : return "MaterialsRheologyE"; - case MaterialsRheologyEbarEnum : return "MaterialsRheologyEbar"; - case MaterialsRheologyEcEnum : return "MaterialsRheologyEc"; - case MaterialsRheologyEcbarEnum : return "MaterialsRheologyEcbar"; - case MaterialsRheologyEsEnum : return "MaterialsRheologyEs"; - case MaterialsRheologyEsbarEnum : return "MaterialsRheologyEsbar"; - case MaterialsRheologyNEnum : return "MaterialsRheologyN"; - case MeshScaleFactorEnum : return "MeshScaleFactor"; - case MeshVertexonbaseEnum : return "MeshVertexonbase"; - case MeshVertexonboundaryEnum : return "MeshVertexonboundary"; - case MeshVertexonsurfaceEnum : return "MeshVertexonsurface"; - case MisfitEnum : return "Misfit"; - case NeumannfluxEnum : return "Neumannflux"; - case NewDamageEnum : return "NewDamage"; - case NodeEnum : return "Node"; - case OmegaAbsGradientEnum : return "OmegaAbsGradient"; - case P0Enum : return "P0"; - case P1Enum : return "P1"; - case PressureEnum : return "Pressure"; - case RheologyBAbsGradientEnum : return "RheologyBAbsGradient"; - case RheologyBInitialguessEnum : return "RheologyBInitialguess"; - case RheologyBInitialguessMisfitEnum : return "RheologyBInitialguessMisfit"; - case RheologyBbarAbsGradientEnum : return "RheologyBbarAbsGradient"; - case SealevelEnum : return "Sealevel"; - case SealevelEustaticMaskEnum : return "SealevelEustaticMask"; - case SealevelEustaticOceanMaskEnum : return "SealevelEustaticOceanMask"; - case SealevelNEsaEnum : return "SealevelNEsa"; - case SealevelNEsaRateEnum : return "SealevelNEsaRate"; - case SealevelNGiaEnum : return "SealevelNGia"; - case SealevelNGiaRateEnum : return "SealevelNGiaRate"; - case SealevelRSLEnum : return "SealevelRSL"; - case SealevelRSLEustaticEnum : return "SealevelRSLEustatic"; - case SealevelRSLEustaticRateEnum : return "SealevelRSLEustaticRate"; - case SealevelRSLRateEnum : return "SealevelRSLRate"; - case SealevelUEastEsaEnum : return "SealevelUEastEsa"; - case SealevelUEsaEnum : return "SealevelUEsa"; - case SealevelUEsaRateEnum : return "SealevelUEsaRate"; - case SealevelUGiaEnum : return "SealevelUGia"; - case SealevelUGiaRateEnum : return "SealevelUGiaRate"; - case SealevelUNorthEsaEnum : return "SealevelUNorthEsa"; - case SealevelriseCumDeltathicknessEnum : return "SealevelriseCumDeltathickness"; - case SealevelriseDeltathicknessEnum : return "SealevelriseDeltathickness"; - case SealevelriseSpcthicknessEnum : return "SealevelriseSpcthickness"; - case SealevelriseStericRateEnum : return "SealevelriseStericRate"; - case SedimentHeadEnum : return "SedimentHead"; - case SedimentHeadHydrostepEnum : return "SedimentHeadHydrostep"; - case SedimentHeadOldEnum : return "SedimentHeadOld"; - case SedimentHeadResidualEnum : return "SedimentHeadResidual"; - case SedimentHeadStackedEnum : return "SedimentHeadStacked"; - case SigmaNNEnum : return "SigmaNN"; - case SigmaVMEnum : return "SigmaVM"; - case SmbAEnum : return "SmbA"; - case SmbAValueEnum : return "SmbAValue"; - case SmbAccumulationEnum : return "SmbAccumulation"; - case SmbAiniEnum : return "SmbAini"; - case SmbBMaxEnum : return "SmbBMax"; - case SmbBMinEnum : return "SmbBMin"; - case SmbBNegEnum : return "SmbBNeg"; - case SmbBPosEnum : return "SmbBPos"; - case SmbCEnum : return "SmbC"; - case SmbDEnum : return "SmbD"; - case SmbDailyairdensityEnum : return "SmbDailyairdensity"; - case SmbDailyairhumidityEnum : return "SmbDailyairhumidity"; - case SmbDailydlradiationEnum : return "SmbDailydlradiation"; - case SmbDailydsradiationEnum : return "SmbDailydsradiation"; - case SmbDailypressureEnum : return "SmbDailypressure"; - case SmbDailyrainfallEnum : return "SmbDailyrainfall"; - case SmbDailysnowfallEnum : return "SmbDailysnowfall"; - case SmbDailytemperatureEnum : return "SmbDailytemperature"; - case SmbDailywindspeedEnum : return "SmbDailywindspeed"; - case SmbDiniEnum : return "SmbDini"; - case SmbDlwrfEnum : return "SmbDlwrf"; - case SmbDswrfEnum : return "SmbDswrf"; - case SmbDzAddEnum : return "SmbDzAdd"; - case SmbDzEnum : return "SmbDz"; - case SmbDzMinEnum : return "SmbDzMin"; - case SmbDzTopEnum : return "SmbDzTop"; - case SmbDziniEnum : return "SmbDzini"; - case SmbEAirEnum : return "SmbEAir"; - case SmbECEnum : return "SmbEC"; - case SmbECiniEnum : return "SmbECini"; - case SmbElaEnum : return "SmbEla"; - case SmbEvaporationEnum : return "SmbEvaporation"; - case SmbFACEnum : return "SmbFAC"; - case SmbGdnEnum : return "SmbGdn"; - case SmbGdniniEnum : return "SmbGdnini"; - case SmbGspEnum : return "SmbGsp"; - case SmbGspiniEnum : return "SmbGspini"; - case SmbHrefEnum : return "SmbHref"; - case SmbIsInitializedEnum : return "SmbIsInitialized"; - case SmbMAddEnum : return "SmbMAdd"; - case SmbMassBalanceClimateEnum : return "SmbMassBalanceClimate"; - case SmbMassBalanceEnum : return "SmbMassBalance"; - case SmbMeanLHFEnum : return "SmbMeanLHF"; - case SmbMeanSHFEnum : return "SmbMeanSHF"; - case SmbMeanULWEnum : return "SmbMeanULW"; - case SmbMeltEnum : return "SmbMelt"; - case SmbMonthlytemperaturesEnum : return "SmbMonthlytemperatures"; - case SmbNetLWEnum : return "SmbNetLW"; - case SmbNetSWEnum : return "SmbNetSW"; - case SmbPAirEnum : return "SmbPAir"; - case SmbPEnum : return "SmbP"; - case SmbPddfacIceEnum : return "SmbPddfacIce"; - case SmbPddfacSnowEnum : return "SmbPddfacSnow"; - case SmbPrecipitationEnum : return "SmbPrecipitation"; - case SmbPrecipitationsAnomalyEnum : return "SmbPrecipitationsAnomaly"; - case SmbPrecipitationsLgmEnum : return "SmbPrecipitationsLgm"; - case SmbPrecipitationsPresentdayEnum : return "SmbPrecipitationsPresentday"; - case SmbPrecipitationsReconstructedEnum : return "SmbPrecipitationsReconstructed"; - case SmbReEnum : return "SmbRe"; - case SmbRefreezeEnum : return "SmbRefreeze"; - case SmbReiniEnum : return "SmbReini"; - case SmbRunoffEnum : return "SmbRunoff"; - case SmbS0gcmEnum : return "SmbS0gcm"; - case SmbS0pEnum : return "SmbS0p"; - case SmbS0tEnum : return "SmbS0t"; - case SmbSizeiniEnum : return "SmbSizeini"; - case SmbSmbCorrEnum : return "SmbSmbCorr"; - case SmbSmbrefEnum : return "SmbSmbref"; - case SmbTEnum : return "SmbT"; - case SmbTaEnum : return "SmbTa"; - case SmbTeValueEnum : return "SmbTeValue"; - case SmbTemperaturesAnomalyEnum : return "SmbTemperaturesAnomaly"; - case SmbTemperaturesLgmEnum : return "SmbTemperaturesLgm"; - case SmbTemperaturesPresentdayEnum : return "SmbTemperaturesPresentday"; - case SmbTemperaturesReconstructedEnum : return "SmbTemperaturesReconstructed"; - case SmbTiniEnum : return "SmbTini"; - case SmbTmeanEnum : return "SmbTmean"; - case SmbTzEnum : return "SmbTz"; - case SmbVEnum : return "SmbV"; - case SmbVmeanEnum : return "SmbVmean"; - case SmbVzEnum : return "SmbVz"; - case SmbWEnum : return "SmbW"; - case SmbWiniEnum : return "SmbWini"; - case SmbZMaxEnum : return "SmbZMax"; - case SmbZMinEnum : return "SmbZMin"; - case SmbZTopEnum : return "SmbZTop"; - case SmbZYEnum : return "SmbZY"; - case StrainRateeffectiveEnum : return "StrainRateeffective"; - case StrainRateparallelEnum : return "StrainRateparallel"; - case StrainRateperpendicularEnum : return "StrainRateperpendicular"; - case StrainRatexxEnum : return "StrainRatexx"; - case StrainRatexyEnum : return "StrainRatexy"; - case StrainRatexzEnum : return "StrainRatexz"; - case StrainRateyyEnum : return "StrainRateyy"; - case StrainRateyzEnum : return "StrainRateyz"; - case StrainRatezzEnum : return "StrainRatezz"; - case StressMaxPrincipalEnum : return "StressMaxPrincipal"; - case StressTensorxxEnum : return "StressTensorxx"; - case StressTensorxyEnum : return "StressTensorxy"; - case StressTensorxzEnum : return "StressTensorxz"; - case StressTensoryyEnum : return "StressTensoryy"; - case StressTensoryzEnum : return "StressTensoryz"; - case StressTensorzzEnum : return "StressTensorzz"; - case SurfaceAbsMisfitEnum : return "SurfaceAbsMisfit"; - case SurfaceAbsVelMisfitEnum : return "SurfaceAbsVelMisfit"; - case SurfaceAreaEnum : return "SurfaceArea"; - case SurfaceAverageVelMisfitEnum : return "SurfaceAverageVelMisfit"; - case SurfaceCrevasseEnum : return "SurfaceCrevasse"; - case SurfaceEnum : return "Surface"; - case SurfaceLogVelMisfitEnum : return "SurfaceLogVelMisfit"; - case SurfaceLogVxVyMisfitEnum : return "SurfaceLogVxVyMisfit"; - case SurfaceObservationEnum : return "SurfaceObservation"; - case SurfaceRelVelMisfitEnum : return "SurfaceRelVelMisfit"; - case SurfaceSlopeXEnum : return "SurfaceSlopeX"; - case SurfaceSlopeYEnum : return "SurfaceSlopeY"; - case TemperatureEnum : return "Temperature"; - case TemperaturePDDEnum : return "TemperaturePDD"; - case TemperaturePicardEnum : return "TemperaturePicard"; - case TemperatureSEMICEnum : return "TemperatureSEMIC"; - case ThermalSpctemperatureEnum : return "ThermalSpctemperature"; - case ThicknessAbsGradientEnum : return "ThicknessAbsGradient"; - case ThicknessAbsMisfitEnum : return "ThicknessAbsMisfit"; - case ThicknessAcrossGradientEnum : return "ThicknessAcrossGradient"; - case ThicknessAlongGradientEnum : return "ThicknessAlongGradient"; - case ThicknessEnum : return "Thickness"; - case ThicknessPositiveEnum : return "ThicknessPositive"; - case VelEnum : return "Vel"; - case VxAverageEnum : return "VxAverage"; - case VxEnum : return "Vx"; - case VxMeshEnum : return "VxMesh"; - case VxObsEnum : return "VxObs"; - case VyAverageEnum : return "VyAverage"; - case VyEnum : return "Vy"; - case VyMeshEnum : return "VyMesh"; - case VyObsEnum : return "VyObs"; - case VzEnum : return "Vz"; - case VzFSEnum : return "VzFS"; - case VzHOEnum : return "VzHO"; - case VzMeshEnum : return "VzMesh"; - case VzSSAEnum : return "VzSSA"; - case WaterColumnOldEnum : return "WaterColumnOld"; - case WatercolumnEnum : return "Watercolumn"; - case WaterfractionDrainageEnum : return "WaterfractionDrainage"; - case WaterfractionDrainageIntegratedEnum : return "WaterfractionDrainageIntegrated"; - case WaterfractionEnum : return "Waterfraction"; - case WaterheightEnum : return "Waterheight"; - case WeightsSurfaceObservationEnum : return "WeightsSurfaceObservation"; - case Outputdefinition1Enum : return "Outputdefinition1"; - case Outputdefinition10Enum : return "Outputdefinition10"; - case Outputdefinition11Enum : return "Outputdefinition11"; - case Outputdefinition12Enum : return "Outputdefinition12"; - case Outputdefinition13Enum : return "Outputdefinition13"; - case Outputdefinition14Enum : return "Outputdefinition14"; - case Outputdefinition15Enum : return "Outputdefinition15"; - case Outputdefinition16Enum : return "Outputdefinition16"; - case Outputdefinition17Enum : return "Outputdefinition17"; - case Outputdefinition18Enum : return "Outputdefinition18"; - case Outputdefinition19Enum : return "Outputdefinition19"; - case Outputdefinition20Enum : return "Outputdefinition20"; - case Outputdefinition21Enum : return "Outputdefinition21"; - case Outputdefinition22Enum : return "Outputdefinition22"; - case Outputdefinition23Enum : return "Outputdefinition23"; - case Outputdefinition24Enum : return "Outputdefinition24"; - case Outputdefinition25Enum : return "Outputdefinition25"; - case Outputdefinition26Enum : return "Outputdefinition26"; - case Outputdefinition27Enum : return "Outputdefinition27"; - case Outputdefinition28Enum : return "Outputdefinition28"; - case Outputdefinition29Enum : return "Outputdefinition29"; - case Outputdefinition2Enum : return "Outputdefinition2"; - case Outputdefinition30Enum : return "Outputdefinition30"; - case Outputdefinition31Enum : return "Outputdefinition31"; - case Outputdefinition32Enum : return "Outputdefinition32"; - case Outputdefinition33Enum : return "Outputdefinition33"; - case Outputdefinition34Enum : return "Outputdefinition34"; - case Outputdefinition35Enum : return "Outputdefinition35"; - case Outputdefinition36Enum : return "Outputdefinition36"; - case Outputdefinition37Enum : return "Outputdefinition37"; - case Outputdefinition38Enum : return "Outputdefinition38"; - case Outputdefinition39Enum : return "Outputdefinition39"; - case Outputdefinition3Enum : return "Outputdefinition3"; - case Outputdefinition40Enum : return "Outputdefinition40"; - case Outputdefinition41Enum : return "Outputdefinition41"; - case Outputdefinition42Enum : return "Outputdefinition42"; - case Outputdefinition43Enum : return "Outputdefinition43"; - case Outputdefinition44Enum : return "Outputdefinition44"; - case Outputdefinition45Enum : return "Outputdefinition45"; - case Outputdefinition46Enum : return "Outputdefinition46"; - case Outputdefinition47Enum : return "Outputdefinition47"; - case Outputdefinition48Enum : return "Outputdefinition48"; - case Outputdefinition49Enum : return "Outputdefinition49"; - case Outputdefinition4Enum : return "Outputdefinition4"; - case Outputdefinition50Enum : return "Outputdefinition50"; - case Outputdefinition51Enum : return "Outputdefinition51"; - case Outputdefinition52Enum : return "Outputdefinition52"; - case Outputdefinition53Enum : return "Outputdefinition53"; - case Outputdefinition54Enum : return "Outputdefinition54"; - case Outputdefinition55Enum : return "Outputdefinition55"; - case Outputdefinition56Enum : return "Outputdefinition56"; - case Outputdefinition57Enum : return "Outputdefinition57"; - case Outputdefinition58Enum : return "Outputdefinition58"; - case Outputdefinition59Enum : return "Outputdefinition59"; - case Outputdefinition5Enum : return "Outputdefinition5"; - case Outputdefinition60Enum : return "Outputdefinition60"; - case Outputdefinition61Enum : return "Outputdefinition61"; - case Outputdefinition62Enum : return "Outputdefinition62"; - case Outputdefinition63Enum : return "Outputdefinition63"; - case Outputdefinition64Enum : return "Outputdefinition64"; - case Outputdefinition65Enum : return "Outputdefinition65"; - case Outputdefinition66Enum : return "Outputdefinition66"; - case Outputdefinition67Enum : return "Outputdefinition67"; - case Outputdefinition68Enum : return "Outputdefinition68"; - case Outputdefinition69Enum : return "Outputdefinition69"; - case Outputdefinition6Enum : return "Outputdefinition6"; - case Outputdefinition70Enum : return "Outputdefinition70"; - case Outputdefinition71Enum : return "Outputdefinition71"; - case Outputdefinition72Enum : return "Outputdefinition72"; - case Outputdefinition73Enum : return "Outputdefinition73"; - case Outputdefinition74Enum : return "Outputdefinition74"; - case Outputdefinition75Enum : return "Outputdefinition75"; - case Outputdefinition76Enum : return "Outputdefinition76"; - case Outputdefinition77Enum : return "Outputdefinition77"; - case Outputdefinition78Enum : return "Outputdefinition78"; - case Outputdefinition79Enum : return "Outputdefinition79"; - case Outputdefinition7Enum : return "Outputdefinition7"; - case Outputdefinition80Enum : return "Outputdefinition80"; - case Outputdefinition81Enum : return "Outputdefinition81"; - case Outputdefinition82Enum : return "Outputdefinition82"; - case Outputdefinition83Enum : return "Outputdefinition83"; - case Outputdefinition84Enum : return "Outputdefinition84"; - case Outputdefinition85Enum : return "Outputdefinition85"; - case Outputdefinition86Enum : return "Outputdefinition86"; - case Outputdefinition87Enum : return "Outputdefinition87"; - case Outputdefinition88Enum : return "Outputdefinition88"; - case Outputdefinition89Enum : return "Outputdefinition89"; - case Outputdefinition8Enum : return "Outputdefinition8"; - case Outputdefinition90Enum : return "Outputdefinition90"; - case Outputdefinition91Enum : return "Outputdefinition91"; - case Outputdefinition92Enum : return "Outputdefinition92"; - case Outputdefinition93Enum : return "Outputdefinition93"; - case Outputdefinition94Enum : return "Outputdefinition94"; - case Outputdefinition95Enum : return "Outputdefinition95"; - case Outputdefinition96Enum : return "Outputdefinition96"; - case Outputdefinition97Enum : return "Outputdefinition97"; - case Outputdefinition98Enum : return "Outputdefinition98"; - case Outputdefinition99Enum : return "Outputdefinition99"; - case Outputdefinition9Enum : return "Outputdefinition9"; - case Outputdefinition100Enum : return "Outputdefinition100"; - case InputsENDEnum : return "InputsEND"; - case AbsoluteEnum : return "Absolute"; - case AdaptiveTimesteppingEnum : return "AdaptiveTimestepping"; - case AdjointBalancethickness2AnalysisEnum : return "AdjointBalancethickness2Analysis"; - case AdjointBalancethicknessAnalysisEnum : return "AdjointBalancethicknessAnalysis"; - case AdjointHorizAnalysisEnum : return "AdjointHorizAnalysis"; - case AggressiveMigrationEnum : return "AggressiveMigration"; - case AmrBamgEnum : return "AmrBamg"; - case AmrNeopzEnum : return "AmrNeopz"; - case AndroidFrictionCoefficientEnum : return "AndroidFrictionCoefficient"; - case ArrheniusEnum : return "Arrhenius"; - case AutodiffJacobianEnum : return "AutodiffJacobian"; - case Balancethickness2AnalysisEnum : return "Balancethickness2Analysis"; - case Balancethickness2SolutionEnum : return "Balancethickness2Solution"; - case BalancethicknessAnalysisEnum : return "BalancethicknessAnalysis"; - case BalancethicknessApparentMassbalanceEnum : return "BalancethicknessApparentMassbalance"; - case BalancethicknessSoftAnalysisEnum : return "BalancethicknessSoftAnalysis"; - case BalancethicknessSoftSolutionEnum : return "BalancethicknessSoftSolution"; - case BalancethicknessSolutionEnum : return "BalancethicknessSolution"; - case BalancethicknessSpcthicknessEnum : return "BalancethicknessSpcthickness"; - case BalancevelocityAnalysisEnum : return "BalancevelocityAnalysis"; - case BalancevelocitySolutionEnum : return "BalancevelocitySolution"; - case BasalforcingsIsmip6Enum : return "BasalforcingsIsmip6"; - case BasalforcingsPicoEnum : return "BasalforcingsPico"; - case BedSlopeSolutionEnum : return "BedSlopeSolution"; - case BoolExternalResultEnum : return "BoolExternalResult"; - case BoolInputEnum : return "BoolInput"; - case BoolParamEnum : return "BoolParam"; - case BoundaryEnum : return "Boundary"; - case BuddJackaEnum : return "BuddJacka"; - case CalvingDev2Enum : return "CalvingDev2"; - case CalvingHabEnum : return "CalvingHab"; - case CalvingLevermannEnum : return "CalvingLevermann"; - case CalvingVonmisesEnum : return "CalvingVonmises"; - case CfdragcoeffabsgradEnum : return "Cfdragcoeffabsgrad"; - case CfsurfacelogvelEnum : return "Cfsurfacelogvel"; - case CfsurfacesquareEnum : return "Cfsurfacesquare"; - case ChannelEnum : return "Channel"; - case ChannelAreaEnum : return "ChannelArea"; - case ClosedEnum : return "Closed"; - case ColinearEnum : return "Colinear"; - case ConstraintsEnum : return "Constraints"; - case ContactEnum : return "Contact"; - case ContourEnum : return "Contour"; - case ContoursEnum : return "Contours"; - case ControlInputEnum : return "ControlInput"; - case ControlInputGradEnum : return "ControlInputGrad"; - case ControlInputMaxsEnum : return "ControlInputMaxs"; - case ControlInputMinsEnum : return "ControlInputMins"; - case ControlInputValuesEnum : return "ControlInputValues"; - case CrouzeixRaviartEnum : return "CrouzeixRaviart"; - case CuffeyEnum : return "Cuffey"; - case CuffeyTemperateEnum : return "CuffeyTemperate"; - case DamageEvolutionAnalysisEnum : return "DamageEvolutionAnalysis"; - case DamageEvolutionSolutionEnum : return "DamageEvolutionSolution"; - case DataSetEnum : return "DataSet"; - case DataSetParamEnum : return "DataSetParam"; - case DatasetInputEnum : return "DatasetInput"; - case DefaultAnalysisEnum : return "DefaultAnalysis"; - case DefaultCalvingEnum : return "DefaultCalving"; - case DenseEnum : return "Dense"; - case DependentObjectEnum : return "DependentObject"; - case DepthAverageAnalysisEnum : return "DepthAverageAnalysis"; - case DeviatoricStressErrorEstimatorEnum : return "DeviatoricStressErrorEstimator"; - case DivergenceEnum : return "Divergence"; - case Domain3DsurfaceEnum : return "Domain3Dsurface"; - case DoubleArrayInputEnum : return "DoubleArrayInput"; - case DoubleExternalResultEnum : return "DoubleExternalResult"; - case DoubleInputEnum : return "DoubleInput"; - case DoubleMatArrayParamEnum : return "DoubleMatArrayParam"; - case DoubleMatExternalResultEnum : return "DoubleMatExternalResult"; - case DoubleMatParamEnum : return "DoubleMatParam"; - case DoubleParamEnum : return "DoubleParam"; - case DoubleVecParamEnum : return "DoubleVecParam"; - case ElementEnum : return "Element"; - case ElementHookEnum : return "ElementHook"; - case ElementSIdEnum : return "ElementSId"; - case EnthalpyAnalysisEnum : return "EnthalpyAnalysis"; - case EsaAnalysisEnum : return "EsaAnalysis"; - case EsaSolutionEnum : return "EsaSolution"; - case EsaTransitionsEnum : return "EsaTransitions"; - case ExternalResultEnum : return "ExternalResult"; - case ExtrapolationAnalysisEnum : return "ExtrapolationAnalysis"; - case ExtrudeFromBaseAnalysisEnum : return "ExtrudeFromBaseAnalysis"; - case ExtrudeFromTopAnalysisEnum : return "ExtrudeFromTopAnalysis"; - case FSApproximationEnum : return "FSApproximation"; - case FSSolverEnum : return "FSSolver"; - case FSpressureEnum : return "FSpressure"; - case FSvelocityEnum : return "FSvelocity"; - case FemModelEnum : return "FemModel"; - case FileParamEnum : return "FileParam"; - case FixedTimesteppingEnum : return "FixedTimestepping"; - case FloatingAreaEnum : return "FloatingArea"; - case FloatingAreaScaledEnum : return "FloatingAreaScaled"; - case FloatingMeltRateEnum : return "FloatingMeltRate"; - case FreeEnum : return "Free"; - case FreeSurfaceBaseAnalysisEnum : return "FreeSurfaceBaseAnalysis"; - case FreeSurfaceTopAnalysisEnum : return "FreeSurfaceTopAnalysis"; - case FrontalForcingsDefaultEnum : return "FrontalForcingsDefault"; - case FrontalForcingsRignotEnum : return "FrontalForcingsRignot"; - case FsetEnum : return "Fset"; - case FullMeltOnPartiallyFloatingEnum : return "FullMeltOnPartiallyFloating"; - case GLheightadvectionAnalysisEnum : return "GLheightadvectionAnalysis"; - case GaussPentaEnum : return "GaussPenta"; - case GaussSegEnum : return "GaussSeg"; - case GaussTetraEnum : return "GaussTetra"; - case GaussTriaEnum : return "GaussTria"; - case GenericOptionEnum : return "GenericOption"; - case GenericParamEnum : return "GenericParam"; - case GiaIvinsAnalysisEnum : return "GiaIvinsAnalysis"; - case GiaSolutionEnum : return "GiaSolution"; - case Gradient1Enum : return "Gradient1"; - case Gradient2Enum : return "Gradient2"; - case Gradient3Enum : return "Gradient3"; - case GroundedAreaEnum : return "GroundedArea"; - case GroundedAreaScaledEnum : return "GroundedAreaScaled"; - case GroundingOnlyEnum : return "GroundingOnly"; - case GroundinglineMassFluxEnum : return "GroundinglineMassFlux"; - case GsetEnum : return "Gset"; - case GslEnum : return "Gsl"; - case HOApproximationEnum : return "HOApproximation"; - case HOFSApproximationEnum : return "HOFSApproximation"; - case HookEnum : return "Hook"; - case HydrologyDCEfficientAnalysisEnum : return "HydrologyDCEfficientAnalysis"; - case HydrologyDCInefficientAnalysisEnum : return "HydrologyDCInefficientAnalysis"; - case HydrologyGlaDSAnalysisEnum : return "HydrologyGlaDSAnalysis"; - case HydrologyGlaDSEnum : return "HydrologyGlaDS"; - case HydrologyPismAnalysisEnum : return "HydrologyPismAnalysis"; - case HydrologyShaktiAnalysisEnum : return "HydrologyShaktiAnalysis"; - case HydrologyShreveAnalysisEnum : return "HydrologyShreveAnalysis"; - case HydrologySolutionEnum : return "HydrologySolution"; - case HydrologydcEnum : return "Hydrologydc"; - case HydrologypismEnum : return "Hydrologypism"; - case HydrologyshaktiEnum : return "Hydrologyshakti"; - case HydrologyshreveEnum : return "Hydrologyshreve"; - case IceMassEnum : return "IceMass"; - case IceMassScaledEnum : return "IceMassScaled"; - case IceVolumeAboveFloatationEnum : return "IceVolumeAboveFloatation"; - case IceVolumeAboveFloatationScaledEnum : return "IceVolumeAboveFloatationScaled"; - case IceVolumeEnum : return "IceVolume"; - case IceVolumeScaledEnum : return "IceVolumeScaled"; - case IcefrontMassFluxEnum : return "IcefrontMassFlux"; - case IcefrontMassFluxLevelsetEnum : return "IcefrontMassFluxLevelset"; - case IncrementalEnum : return "Incremental"; - case IndexedEnum : return "Indexed"; - case IntExternalResultEnum : return "IntExternalResult"; - case IntInputEnum : return "IntInput"; - case IntMatExternalResultEnum : return "IntMatExternalResult"; - case IntMatParamEnum : return "IntMatParam"; - case IntParamEnum : return "IntParam"; - case IntVecParamEnum : return "IntVecParam"; - case InternalEnum : return "Internal"; - case IntersectEnum : return "Intersect"; - case InversionVzObsEnum : return "InversionVzObs"; - case JEnum : return "J"; - case L1L2ApproximationEnum : return "L1L2Approximation"; - case L2ProjectionBaseAnalysisEnum : return "L2ProjectionBaseAnalysis"; - case L2ProjectionEPLAnalysisEnum : return "L2ProjectionEPLAnalysis"; - case LACrouzeixRaviartEnum : return "LACrouzeixRaviart"; - case LATaylorHoodEnum : return "LATaylorHood"; - case LambdaSEnum : return "LambdaS"; - case LevelsetAnalysisEnum : return "LevelsetAnalysis"; - case LevelsetfunctionPicardEnum : return "LevelsetfunctionPicard"; - case LinearFloatingMeltRateEnum : return "LinearFloatingMeltRate"; - case LliboutryDuvalEnum : return "LliboutryDuval"; - case LoadsEnum : return "Loads"; - case LoveAnalysisEnum : return "LoveAnalysis"; - case LoveHiEnum : return "LoveHi"; - case LoveHrEnum : return "LoveHr"; - case LoveKernelsImagEnum : return "LoveKernelsImag"; - case LoveKernelsRealEnum : return "LoveKernelsReal"; - case LoveKiEnum : return "LoveKi"; - case LoveKrEnum : return "LoveKr"; - case LoveLiEnum : return "LoveLi"; - case LoveLrEnum : return "LoveLr"; - case LoveSolutionEnum : return "LoveSolution"; - case MINIEnum : return "MINI"; - case MINIcondensedEnum : return "MINIcondensed"; - case MantlePlumeGeothermalFluxEnum : return "MantlePlumeGeothermalFlux"; - case MassFluxEnum : return "MassFlux"; - case MassconEnum : return "Masscon"; - case MassconaxpbyEnum : return "Massconaxpby"; - case MassfluxatgateEnum : return "Massfluxatgate"; - case MasstransportAnalysisEnum : return "MasstransportAnalysis"; - case MasstransportSolutionEnum : return "MasstransportSolution"; - case MatdamageiceEnum : return "Matdamageice"; - case MatenhancediceEnum : return "Matenhancedice"; - case MaterialsEnum : return "Materials"; - case MatestarEnum : return "Matestar"; - case MaticeEnum : return "Matice"; - case MatlithoEnum : return "Matlitho"; - case MatrixParamEnum : return "MatrixParam"; - case MaxAbsVxEnum : return "MaxAbsVx"; - case MaxAbsVyEnum : return "MaxAbsVy"; - case MaxAbsVzEnum : return "MaxAbsVz"; - case MaxDivergenceEnum : return "MaxDivergence"; - case MaxVelEnum : return "MaxVel"; - case MaxVxEnum : return "MaxVx"; - case MaxVyEnum : return "MaxVy"; - case MaxVzEnum : return "MaxVz"; - case MelangeEnum : return "Melange"; - case MeltingAnalysisEnum : return "MeltingAnalysis"; - case MeshElementsEnum : return "MeshElements"; - case MeshXEnum : return "MeshX"; - case MeshYEnum : return "MeshY"; - case MinVelEnum : return "MinVel"; - case MinVxEnum : return "MinVx"; - case MinVyEnum : return "MinVy"; - case MinVzEnum : return "MinVz"; - case MismipFloatingMeltRateEnum : return "MismipFloatingMeltRate"; - case MoulinEnum : return "Moulin"; - case MpiDenseEnum : return "MpiDense"; - case MpiEnum : return "Mpi"; - case MpiSparseEnum : return "MpiSparse"; - case MumpsEnum : return "Mumps"; - case NoFrictionOnPartiallyFloatingEnum : return "NoFrictionOnPartiallyFloating"; - case NoMeltOnPartiallyFloatingEnum : return "NoMeltOnPartiallyFloating"; - case NodalEnum : return "Nodal"; - case NodalvalueEnum : return "Nodalvalue"; - case NodeSIdEnum : return "NodeSId"; - case NoneApproximationEnum : return "NoneApproximation"; - case NoneEnum : return "None"; - case NumberedcostfunctionEnum : return "Numberedcostfunction"; - case NumericalfluxEnum : return "Numericalflux"; - case OldGradientEnum : return "OldGradient"; - case OneLayerP4zEnum : return "OneLayerP4z"; - case OpenEnum : return "Open"; - case OptionEnum : return "Option"; - case P0ArrayEnum : return "P0Array"; - case P1DGEnum : return "P1DG"; - case P1P1Enum : return "P1P1"; - case P1P1GLSEnum : return "P1P1GLS"; - case P1bubbleEnum : return "P1bubble"; - case P1bubblecondensedEnum : return "P1bubblecondensed"; - case P1xP2Enum : return "P1xP2"; - case P1xP3Enum : return "P1xP3"; - case P1xP4Enum : return "P1xP4"; - case P2Enum : return "P2"; - case P2bubbleEnum : return "P2bubble"; - case P2bubblecondensedEnum : return "P2bubblecondensed"; - case P2xP1Enum : return "P2xP1"; - case P2xP4Enum : return "P2xP4"; - case PatersonEnum : return "Paterson"; - case PengridEnum : return "Pengrid"; - case PenpairEnum : return "Penpair"; - case PentaEnum : return "Penta"; - case PentaInputEnum : return "PentaInput"; - case ProfilerEnum : return "Profiler"; - case ProfilingCurrentFlopsEnum : return "ProfilingCurrentFlops"; - case ProfilingCurrentMemEnum : return "ProfilingCurrentMem"; - case ProfilingSolutionTimeEnum : return "ProfilingSolutionTime"; - case RegionaloutputEnum : return "Regionaloutput"; - case RegularEnum : return "Regular"; - case RiftfrontEnum : return "Riftfront"; - case SIAApproximationEnum : return "SIAApproximation"; - case SMBcomponentsEnum : return "SMBcomponents"; - case SMBd18opddEnum : return "SMBd18opdd"; - case SMBforcingEnum : return "SMBforcing"; - case SMBgcmEnum : return "SMBgcm"; - case SMBgembEnum : return "SMBgemb"; - case SMBgradientsEnum : return "SMBgradients"; - case SMBgradientscomponentsEnum : return "SMBgradientscomponents"; - case SMBgradientselaEnum : return "SMBgradientsela"; - case SMBhenningEnum : return "SMBhenning"; - case SMBmeltcomponentsEnum : return "SMBmeltcomponents"; - case SMBpddEnum : return "SMBpdd"; - case SMBpddSicopolisEnum : return "SMBpddSicopolis"; - case SMBsemicEnum : return "SMBsemic"; - case SSAApproximationEnum : return "SSAApproximation"; - case SSAFSApproximationEnum : return "SSAFSApproximation"; - case SSAHOApproximationEnum : return "SSAHOApproximation"; - case ScaledEnum : return "Scaled"; - case SealevelAbsoluteEnum : return "SealevelAbsolute"; - case SealevelEmotionEnum : return "SealevelEmotion"; - case SealevelInertiaTensorXZEnum : return "SealevelInertiaTensorXZ"; - case SealevelInertiaTensorYZEnum : return "SealevelInertiaTensorYZ"; - case SealevelInertiaTensorZZEnum : return "SealevelInertiaTensorZZ"; - case SealevelNmotionEnum : return "SealevelNmotion"; - case SealevelUmotionEnum : return "SealevelUmotion"; - case SealevelriseAnalysisEnum : return "SealevelriseAnalysis"; - case SealevelriseSolutionEnum : return "SealevelriseSolution"; - case SegEnum : return "Seg"; - case SegInputEnum : return "SegInput"; - case SegmentEnum : return "Segment"; - case SegmentRiftfrontEnum : return "SegmentRiftfront"; - case SeparateEnum : return "Separate"; - case SeqEnum : return "Seq"; - case SmbAnalysisEnum : return "SmbAnalysis"; - case SmbSolutionEnum : return "SmbSolution"; - case SmoothAnalysisEnum : return "SmoothAnalysis"; - case SoftMigrationEnum : return "SoftMigration"; - case SpatialLinearFloatingMeltRateEnum : return "SpatialLinearFloatingMeltRate"; - case SpcDynamicEnum : return "SpcDynamic"; - case SpcStaticEnum : return "SpcStatic"; - case SpcTransientEnum : return "SpcTransient"; - case SsetEnum : return "Sset"; - case SteadystateSolutionEnum : return "SteadystateSolution"; - case StressIntensityFactorEnum : return "StressIntensityFactor"; - case StressbalanceAnalysisEnum : return "StressbalanceAnalysis"; - case StressbalanceConvergenceNumStepsEnum : return "StressbalanceConvergenceNumSteps"; - case StressbalanceSIAAnalysisEnum : return "StressbalanceSIAAnalysis"; - case StressbalanceSolutionEnum : return "StressbalanceSolution"; - case StressbalanceVerticalAnalysisEnum : return "StressbalanceVerticalAnalysis"; - case StringArrayParamEnum : return "StringArrayParam"; - case StringExternalResultEnum : return "StringExternalResult"; - case StringParamEnum : return "StringParam"; - case SubelementFriction1Enum : return "SubelementFriction1"; - case SubelementFriction2Enum : return "SubelementFriction2"; - case SubelementMelt1Enum : return "SubelementMelt1"; - case SubelementMelt2Enum : return "SubelementMelt2"; - case SubelementMigrationEnum : return "SubelementMigration"; - case SurfaceSlopeSolutionEnum : return "SurfaceSlopeSolution"; - case TaylorHoodEnum : return "TaylorHood"; - case TetraEnum : return "Tetra"; - case TetraInputEnum : return "TetraInput"; - case ThermalAnalysisEnum : return "ThermalAnalysis"; - case ThermalSolutionEnum : return "ThermalSolution"; - case ThicknessErrorEstimatorEnum : return "ThicknessErrorEstimator"; - case TotalCalvingFluxEnum : return "TotalCalvingFlux"; - case TotalCalvingFluxLevelsetEnum : return "TotalCalvingFluxLevelset"; - case TotalFloatingBmbEnum : return "TotalFloatingBmb"; - case TotalFloatingBmbScaledEnum : return "TotalFloatingBmbScaled"; - case TotalGroundedBmbEnum : return "TotalGroundedBmb"; - case TotalGroundedBmbScaledEnum : return "TotalGroundedBmbScaled"; - case TotalSmbEnum : return "TotalSmb"; - case TotalSmbScaledEnum : return "TotalSmbScaled"; - case TransientArrayParamEnum : return "TransientArrayParam"; - case TransientInputEnum : return "TransientInput"; - case TransientParamEnum : return "TransientParam"; - case TransientSolutionEnum : return "TransientSolution"; - case TriaEnum : return "Tria"; - case TriaInputEnum : return "TriaInput"; - case UzawaPressureAnalysisEnum : return "UzawaPressureAnalysis"; - case VectorParamEnum : return "VectorParam"; - case VertexEnum : return "Vertex"; - case VertexLIdEnum : return "VertexLId"; - case VertexPIdEnum : return "VertexPId"; - case VertexSIdEnum : return "VertexSId"; - case VerticesEnum : return "Vertices"; - case ViscousHeatingEnum : return "ViscousHeating"; - case WaterEnum : return "Water"; - case XTaylorHoodEnum : return "XTaylorHood"; - case XYEnum : return "XY"; - case XYZEnum : return "XYZ"; - case BalancethicknessD0Enum : return "BalancethicknessD0"; - case BalancethicknessDiffusionCoefficientEnum : return "BalancethicknessDiffusionCoefficient"; - case BilinearInterpEnum : return "BilinearInterp"; - case CalvingdevCoeffEnum : return "CalvingdevCoeff"; - case DeviatoricStressEnum : return "DeviatoricStress"; - case EtaAbsGradientEnum : return "EtaAbsGradient"; - case MeshZEnum : return "MeshZ"; - case NearestInterpEnum : return "NearestInterp"; - case OutputdefinitionListEnum : return "OutputdefinitionList"; - case SealevelObsEnum : return "SealevelObs"; - case SealevelWeightsEnum : return "SealevelWeights"; - case StrainRateEnum : return "StrainRate"; - case StressTensorEnum : return "StressTensor"; - case StressbalanceViscosityOvershootEnum : return "StressbalanceViscosityOvershoot"; - case SubelementMigration4Enum : return "SubelementMigration4"; - case TimesteppingTimeAdaptEnum : return "TimesteppingTimeAdapt"; - case TriangleInterpEnum : return "TriangleInterp"; - case MaximumNumberOfDefinitionsEnum : return "MaximumNumberOfDefinitions"; default : return "unknown"; Index: /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp (revision 23992) +++ /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp (revision 23993) @@ -17,1274 +17,5 @@ if(stage==1){ - if (strcmp(name,"ParametersSTART")==0) return ParametersSTARTEnum; - else if (strcmp(name,"AdolcParam")==0) return AdolcParamEnum; - else if (strcmp(name,"AmrDeviatoricErrorGroupThreshold")==0) return AmrDeviatoricErrorGroupThresholdEnum; - else if (strcmp(name,"AmrDeviatoricErrorMaximum")==0) return AmrDeviatoricErrorMaximumEnum; - else if (strcmp(name,"AmrDeviatoricErrorResolution")==0) return AmrDeviatoricErrorResolutionEnum; - else if (strcmp(name,"AmrDeviatoricErrorThreshold")==0) return AmrDeviatoricErrorThresholdEnum; - else if (strcmp(name,"AmrErr")==0) return AmrErrEnum; - else if (strcmp(name,"AmrField")==0) return AmrFieldEnum; - else if (strcmp(name,"AmrGradation")==0) return AmrGradationEnum; - else if (strcmp(name,"AmrGroundingLineDistance")==0) return AmrGroundingLineDistanceEnum; - else if (strcmp(name,"AmrGroundingLineResolution")==0) return AmrGroundingLineResolutionEnum; - else if (strcmp(name,"AmrHmax")==0) return AmrHmaxEnum; - else if (strcmp(name,"AmrHmin")==0) return AmrHminEnum; - else if (strcmp(name,"AmrIceFrontDistance")==0) return AmrIceFrontDistanceEnum; - else if (strcmp(name,"AmrIceFrontResolution")==0) return AmrIceFrontResolutionEnum; - else if (strcmp(name,"AmrKeepMetric")==0) return AmrKeepMetricEnum; - else if (strcmp(name,"AmrLag")==0) return AmrLagEnum; - else if (strcmp(name,"AmrLevelMax")==0) return AmrLevelMaxEnum; - else if (strcmp(name,"AmrRestart")==0) return AmrRestartEnum; - else if (strcmp(name,"AmrThicknessErrorGroupThreshold")==0) return AmrThicknessErrorGroupThresholdEnum; - else if (strcmp(name,"AmrThicknessErrorMaximum")==0) return AmrThicknessErrorMaximumEnum; - else if (strcmp(name,"AmrThicknessErrorResolution")==0) return AmrThicknessErrorResolutionEnum; - else if (strcmp(name,"AmrThicknessErrorThreshold")==0) return AmrThicknessErrorThresholdEnum; - else if (strcmp(name,"AmrType")==0) return AmrTypeEnum; - else if (strcmp(name,"AnalysisCounter")==0) return AnalysisCounterEnum; - else if (strcmp(name,"AnalysisType")==0) return AnalysisTypeEnum; - else if (strcmp(name,"AugmentedLagrangianR")==0) return AugmentedLagrangianREnum; - else if (strcmp(name,"AugmentedLagrangianRholambda")==0) return AugmentedLagrangianRholambdaEnum; - else if (strcmp(name,"AugmentedLagrangianRhop")==0) return AugmentedLagrangianRhopEnum; - else if (strcmp(name,"AugmentedLagrangianRlambda")==0) return AugmentedLagrangianRlambdaEnum; - else if (strcmp(name,"AugmentedLagrangianTheta")==0) return AugmentedLagrangianThetaEnum; - else if (strcmp(name,"AutodiffCbufsize")==0) return AutodiffCbufsizeEnum; - else if (strcmp(name,"AutodiffDependentObjects")==0) return AutodiffDependentObjectsEnum; - else if (strcmp(name,"AutodiffDriver")==0) return AutodiffDriverEnum; - else if (strcmp(name,"AutodiffFosForwardIndex")==0) return AutodiffFosForwardIndexEnum; - else if (strcmp(name,"AutodiffFosReverseIndex")==0) return AutodiffFosReverseIndexEnum; - else if (strcmp(name,"AutodiffFovForwardIndices")==0) return AutodiffFovForwardIndicesEnum; - else if (strcmp(name,"AutodiffGcTriggerMaxSize")==0) return AutodiffGcTriggerMaxSizeEnum; - else if (strcmp(name,"AutodiffGcTriggerRatio")==0) return AutodiffGcTriggerRatioEnum; - else if (strcmp(name,"AutodiffIsautodiff")==0) return AutodiffIsautodiffEnum; - else if (strcmp(name,"AutodiffLbufsize")==0) return AutodiffLbufsizeEnum; - else if (strcmp(name,"AutodiffNumDependents")==0) return AutodiffNumDependentsEnum; - else if (strcmp(name,"AutodiffNumIndependents")==0) return AutodiffNumIndependentsEnum; - else if (strcmp(name,"AutodiffObufsize")==0) return AutodiffObufsizeEnum; - else if (strcmp(name,"AutodiffTapeAlloc")==0) return AutodiffTapeAllocEnum; - else if (strcmp(name,"AutodiffTbufsize")==0) return AutodiffTbufsizeEnum; - else if (strcmp(name,"AutodiffXp")==0) return AutodiffXpEnum; - else if (strcmp(name,"BalancethicknessStabilization")==0) return BalancethicknessStabilizationEnum; - else if (strcmp(name,"BasalforcingsBottomplumedepth")==0) return BasalforcingsBottomplumedepthEnum; - else if (strcmp(name,"BasalforcingsCrustthickness")==0) return BasalforcingsCrustthicknessEnum; - else if (strcmp(name,"BasalforcingsDeepwaterElevation")==0) return BasalforcingsDeepwaterElevationEnum; - else if (strcmp(name,"BasalforcingsDeepwaterMeltingRate")==0) return BasalforcingsDeepwaterMeltingRateEnum; - else if (strcmp(name,"BasalforcingsDtbg")==0) return BasalforcingsDtbgEnum; - else if (strcmp(name,"Basalforcings")==0) return BasalforcingsEnum; - else if (strcmp(name,"BasalforcingsIsmp6AverageTf")==0) return BasalforcingsIsmp6AverageTfEnum; - else if (strcmp(name,"BasalforcingsIsmp6BasinArea")==0) return BasalforcingsIsmp6BasinAreaEnum; - else if (strcmp(name,"BasalforcingsIsmp6DeltaT")==0) return BasalforcingsIsmp6DeltaTEnum; - else if (strcmp(name,"BasalforcingsIsmp6Gamma0")==0) return BasalforcingsIsmp6Gamma0Enum; - else if (strcmp(name,"BasalforcingsIsmp6IsLocal")==0) return BasalforcingsIsmp6IsLocalEnum; - else if (strcmp(name,"BasalforcingsIsmp6NumBasins")==0) return BasalforcingsIsmp6NumBasinsEnum; - else if (strcmp(name,"BasalforcingsIsmp6TfDepths")==0) return BasalforcingsIsmp6TfDepthsEnum; - else if (strcmp(name,"BasalforcingsLowercrustheat")==0) return BasalforcingsLowercrustheatEnum; - else if (strcmp(name,"BasalforcingsMantleconductivity")==0) return BasalforcingsMantleconductivityEnum; - else if (strcmp(name,"BasalforcingsMeltrateFactor")==0) return BasalforcingsMeltrateFactorEnum; - else if (strcmp(name,"BasalforcingsNusselt")==0) return BasalforcingsNusseltEnum; - else if (strcmp(name,"BasalforcingsPicoAverageOverturning")==0) return BasalforcingsPicoAverageOverturningEnum; - else if (strcmp(name,"BasalforcingsPicoAverageSalinity")==0) return BasalforcingsPicoAverageSalinityEnum; - else if (strcmp(name,"BasalforcingsPicoAverageTemperature")==0) return BasalforcingsPicoAverageTemperatureEnum; - else if (strcmp(name,"BasalforcingsPicoBoxArea")==0) return BasalforcingsPicoBoxAreaEnum; - else if (strcmp(name,"BasalforcingsPicoFarOceansalinity")==0) return BasalforcingsPicoFarOceansalinityEnum; - else if (strcmp(name,"BasalforcingsPicoFarOceantemperature")==0) return BasalforcingsPicoFarOceantemperatureEnum; - else if (strcmp(name,"BasalforcingsPicoGammaT")==0) return BasalforcingsPicoGammaTEnum; - else if (strcmp(name,"BasalforcingsPicoIsplume")==0) return BasalforcingsPicoIsplumeEnum; - else if (strcmp(name,"BasalforcingsPicoMaxboxcount")==0) return BasalforcingsPicoMaxboxcountEnum; - else if (strcmp(name,"BasalforcingsPicoNumBasins")==0) return BasalforcingsPicoNumBasinsEnum; - else if (strcmp(name,"BasalforcingsPicoOverturningCoeff")==0) return BasalforcingsPicoOverturningCoeffEnum; - else if (strcmp(name,"BasalforcingsPlumeradius")==0) return BasalforcingsPlumeradiusEnum; - else if (strcmp(name,"BasalforcingsPlumex")==0) return BasalforcingsPlumexEnum; - else if (strcmp(name,"BasalforcingsPlumey")==0) return BasalforcingsPlumeyEnum; - else if (strcmp(name,"BasalforcingsThresholdThickness")==0) return BasalforcingsThresholdThicknessEnum; - else if (strcmp(name,"BasalforcingsTopplumedepth")==0) return BasalforcingsTopplumedepthEnum; - else if (strcmp(name,"BasalforcingsUppercrustheat")==0) return BasalforcingsUppercrustheatEnum; - else if (strcmp(name,"BasalforcingsUppercrustthickness")==0) return BasalforcingsUppercrustthicknessEnum; - else if (strcmp(name,"BasalforcingsUpperdepthMelt")==0) return BasalforcingsUpperdepthMeltEnum; - else if (strcmp(name,"BasalforcingsUpperwaterElevation")==0) return BasalforcingsUpperwaterElevationEnum; - else if (strcmp(name,"BasalforcingsUpperwaterMeltingRate")==0) return BasalforcingsUpperwaterMeltingRateEnum; - else if (strcmp(name,"CalvingCrevasseDepth")==0) return CalvingCrevasseDepthEnum; - else if (strcmp(name,"CalvingHeightAboveFloatation")==0) return CalvingHeightAboveFloatationEnum; - else if (strcmp(name,"CalvingLaw")==0) return CalvingLawEnum; - else if (strcmp(name,"CalvingMax")==0) return CalvingMaxEnum; - else if (strcmp(name,"CalvingMinthickness")==0) return CalvingMinthicknessEnum; - else if (strcmp(name,"ConfigurationType")==0) return ConfigurationTypeEnum; - else if (strcmp(name,"ConstantsG")==0) return ConstantsGEnum; - else if (strcmp(name,"ConstantsReferencetemperature")==0) return ConstantsReferencetemperatureEnum; - else if (strcmp(name,"ConstantsYts")==0) return ConstantsYtsEnum; - else if (strcmp(name,"ControlInputSizeM")==0) return ControlInputSizeMEnum; - else if (strcmp(name,"ControlInputSizeN")==0) return ControlInputSizeNEnum; - else if (strcmp(name,"DamageC1")==0) return DamageC1Enum; - else if (strcmp(name,"DamageC2")==0) return DamageC2Enum; - else if (strcmp(name,"DamageC3")==0) return DamageC3Enum; - else if (strcmp(name,"Damage")==0) return DamageEnum; - else if (strcmp(name,"DamageEquivStress")==0) return DamageEquivStressEnum; - else if (strcmp(name,"DamageEvolutionNumRequestedOutputs")==0) return DamageEvolutionNumRequestedOutputsEnum; - else if (strcmp(name,"DamageEvolutionRequestedOutputs")==0) return DamageEvolutionRequestedOutputsEnum; - else if (strcmp(name,"DamageHealing")==0) return DamageHealingEnum; - else if (strcmp(name,"DamageKappa")==0) return DamageKappaEnum; - else if (strcmp(name,"DamageLaw")==0) return DamageLawEnum; - else if (strcmp(name,"DamageMaxDamage")==0) return DamageMaxDamageEnum; - else if (strcmp(name,"DamageStabilization")==0) return DamageStabilizationEnum; - else if (strcmp(name,"DamageStressThreshold")==0) return DamageStressThresholdEnum; - else if (strcmp(name,"DebugProfiling")==0) return DebugProfilingEnum; - else if (strcmp(name,"DomainDimension")==0) return DomainDimensionEnum; - else if (strcmp(name,"DomainType")==0) return DomainTypeEnum; - else if (strcmp(name,"EarthId")==0) return EarthIdEnum; - else if (strcmp(name,"EplZigZagCounter")==0) return EplZigZagCounterEnum; - else if (strcmp(name,"EsaHElastic")==0) return EsaHElasticEnum; - else if (strcmp(name,"EsaHemisphere")==0) return EsaHemisphereEnum; - else if (strcmp(name,"EsaRequestedOutputs")==0) return EsaRequestedOutputsEnum; - else if (strcmp(name,"EsaUElastic")==0) return EsaUElasticEnum; - else if (strcmp(name,"ExtrapolationVariable")==0) return ExtrapolationVariableEnum; else stage=2; - } - if(stage==2){ - if (strcmp(name,"FemModelComm")==0) return FemModelCommEnum; - else if (strcmp(name,"FlowequationFeFS")==0) return FlowequationFeFSEnum; - else if (strcmp(name,"FlowequationIsFS")==0) return FlowequationIsFSEnum; - else if (strcmp(name,"FlowequationIsHO")==0) return FlowequationIsHOEnum; - else if (strcmp(name,"FlowequationIsL1L2")==0) return FlowequationIsL1L2Enum; - else if (strcmp(name,"FlowequationIsSIA")==0) return FlowequationIsSIAEnum; - else if (strcmp(name,"FlowequationIsSSA")==0) return FlowequationIsSSAEnum; - else if (strcmp(name,"FrictionCoupling")==0) return FrictionCouplingEnum; - else if (strcmp(name,"FrictionDelta")==0) return FrictionDeltaEnum; - else if (strcmp(name,"FrictionF")==0) return FrictionFEnum; - else if (strcmp(name,"FrictionGamma")==0) return FrictionGammaEnum; - else if (strcmp(name,"FrictionLaw")==0) return FrictionLawEnum; - else if (strcmp(name,"FrictionPseudoplasticityExponent")==0) return FrictionPseudoplasticityExponentEnum; - else if (strcmp(name,"FrictionThresholdSpeed")==0) return FrictionThresholdSpeedEnum; - else if (strcmp(name,"FrictionVoidRatio")==0) return FrictionVoidRatioEnum; - else if (strcmp(name,"FrontalForcingsBasinIcefrontArea")==0) return FrontalForcingsBasinIcefrontAreaEnum; - else if (strcmp(name,"FrontalForcingsNumberofBasins")==0) return FrontalForcingsNumberofBasinsEnum; - else if (strcmp(name,"FrontalForcingsParam")==0) return FrontalForcingsParamEnum; - else if (strcmp(name,"GiaCrossSectionShape")==0) return GiaCrossSectionShapeEnum; - else if (strcmp(name,"GroundinglineFrictionInterpolation")==0) return GroundinglineFrictionInterpolationEnum; - else if (strcmp(name,"GroundinglineMeltInterpolation")==0) return GroundinglineMeltInterpolationEnum; - else if (strcmp(name,"GroundinglineMigration")==0) return GroundinglineMigrationEnum; - else if (strcmp(name,"HydrologyCavitySpacing")==0) return HydrologyCavitySpacingEnum; - else if (strcmp(name,"HydrologyChannelConductivity")==0) return HydrologyChannelConductivityEnum; - else if (strcmp(name,"HydrologyChannelSheetWidth")==0) return HydrologyChannelSheetWidthEnum; - else if (strcmp(name,"HydrologyEnglacialVoidRatio")==0) return HydrologyEnglacialVoidRatioEnum; - else if (strcmp(name,"HydrologyIschannels")==0) return HydrologyIschannelsEnum; - else if (strcmp(name,"HydrologyModel")==0) return HydrologyModelEnum; - else if (strcmp(name,"HydrologyNumRequestedOutputs")==0) return HydrologyNumRequestedOutputsEnum; - else if (strcmp(name,"HydrologyPressureMeltCoefficient")==0) return HydrologyPressureMeltCoefficientEnum; - else if (strcmp(name,"HydrologyRelaxation")==0) return HydrologyRelaxationEnum; - else if (strcmp(name,"HydrologyRequestedOutputs")==0) return HydrologyRequestedOutputsEnum; - else if (strcmp(name,"HydrologySedimentKmax")==0) return HydrologySedimentKmaxEnum; - else if (strcmp(name,"HydrologyStepsPerStep")==0) return HydrologyStepsPerStepEnum; - else if (strcmp(name,"HydrologyStorage")==0) return HydrologyStorageEnum; - else if (strcmp(name,"HydrologydcEplColapseThickness")==0) return HydrologydcEplColapseThicknessEnum; - else if (strcmp(name,"HydrologydcEplCompressibility")==0) return HydrologydcEplCompressibilityEnum; - else if (strcmp(name,"HydrologydcEplConductivity")==0) return HydrologydcEplConductivityEnum; - else if (strcmp(name,"HydrologydcEplInitialThickness")==0) return HydrologydcEplInitialThicknessEnum; - else if (strcmp(name,"HydrologydcEplMaxThickness")==0) return HydrologydcEplMaxThicknessEnum; - else if (strcmp(name,"HydrologydcEplPorosity")==0) return HydrologydcEplPorosityEnum; - else if (strcmp(name,"HydrologydcEplThickComp")==0) return HydrologydcEplThickCompEnum; - else if (strcmp(name,"HydrologydcEplflipLock")==0) return HydrologydcEplflipLockEnum; - else if (strcmp(name,"HydrologydcIsefficientlayer")==0) return HydrologydcIsefficientlayerEnum; - else if (strcmp(name,"HydrologydcLeakageFactor")==0) return HydrologydcLeakageFactorEnum; - else if (strcmp(name,"HydrologydcMaxIter")==0) return HydrologydcMaxIterEnum; - else if (strcmp(name,"HydrologydcPenaltyFactor")==0) return HydrologydcPenaltyFactorEnum; - else if (strcmp(name,"HydrologydcPenaltyLock")==0) return HydrologydcPenaltyLockEnum; - else if (strcmp(name,"HydrologydcRelTol")==0) return HydrologydcRelTolEnum; - else if (strcmp(name,"HydrologydcSedimentCompressibility")==0) return HydrologydcSedimentCompressibilityEnum; - else if (strcmp(name,"HydrologydcSedimentPorosity")==0) return HydrologydcSedimentPorosityEnum; - else if (strcmp(name,"HydrologydcSedimentThickness")==0) return HydrologydcSedimentThicknessEnum; - else if (strcmp(name,"HydrologydcSedimentlimit")==0) return HydrologydcSedimentlimitEnum; - else if (strcmp(name,"HydrologydcSedimentlimitFlag")==0) return HydrologydcSedimentlimitFlagEnum; - else if (strcmp(name,"HydrologydcTransferFlag")==0) return HydrologydcTransferFlagEnum; - else if (strcmp(name,"HydrologydcUnconfinedFlag")==0) return HydrologydcUnconfinedFlagEnum; - else if (strcmp(name,"HydrologydcWaterCompressibility")==0) return HydrologydcWaterCompressibilityEnum; - else if (strcmp(name,"Hydrologydt")==0) return HydrologydtEnum; - else if (strcmp(name,"HydrologyshreveStabilization")==0) return HydrologyshreveStabilizationEnum; - else if (strcmp(name,"IcecapToEarthComm")==0) return IcecapToEarthCommEnum; - else if (strcmp(name,"Index")==0) return IndexEnum; - else if (strcmp(name,"InputFileName")==0) return InputFileNameEnum; - else if (strcmp(name,"InputToDepthaverageIn")==0) return InputToDepthaverageInEnum; - else if (strcmp(name,"InputToDepthaverageOut")==0) return InputToDepthaverageOutEnum; - else if (strcmp(name,"InputToExtrude")==0) return InputToExtrudeEnum; - else if (strcmp(name,"InputToL2Project")==0) return InputToL2ProjectEnum; - else if (strcmp(name,"InputToSmooth")==0) return InputToSmoothEnum; - else if (strcmp(name,"InversionAlgorithm")==0) return InversionAlgorithmEnum; - else if (strcmp(name,"InversionControlParameters")==0) return InversionControlParametersEnum; - else if (strcmp(name,"InversionControlScalingFactors")==0) return InversionControlScalingFactorsEnum; - else if (strcmp(name,"InversionCostFunctions")==0) return InversionCostFunctionsEnum; - else if (strcmp(name,"InversionDxmin")==0) return InversionDxminEnum; - else if (strcmp(name,"InversionGatol")==0) return InversionGatolEnum; - else if (strcmp(name,"InversionGradientScaling")==0) return InversionGradientScalingEnum; - else if (strcmp(name,"InversionGrtol")==0) return InversionGrtolEnum; - else if (strcmp(name,"InversionGttol")==0) return InversionGttolEnum; - else if (strcmp(name,"InversionIncompleteAdjoint")==0) return InversionIncompleteAdjointEnum; - else if (strcmp(name,"InversionIscontrol")==0) return InversionIscontrolEnum; - else if (strcmp(name,"InversionMaxiter")==0) return InversionMaxiterEnum; - else if (strcmp(name,"InversionMaxiterPerStep")==0) return InversionMaxiterPerStepEnum; - else if (strcmp(name,"InversionMaxsteps")==0) return InversionMaxstepsEnum; - else if (strcmp(name,"InversionNsteps")==0) return InversionNstepsEnum; - else if (strcmp(name,"InversionNumControlParameters")==0) return InversionNumControlParametersEnum; - else if (strcmp(name,"InversionNumCostFunctions")==0) return InversionNumCostFunctionsEnum; - else if (strcmp(name,"InversionStepThreshold")==0) return InversionStepThresholdEnum; - else if (strcmp(name,"InversionType")==0) return InversionTypeEnum; - else if (strcmp(name,"LevelsetReinitFrequency")==0) return LevelsetReinitFrequencyEnum; - else if (strcmp(name,"LevelsetStabilization")==0) return LevelsetStabilizationEnum; - else if (strcmp(name,"LockFileName")==0) return LockFileNameEnum; - else if (strcmp(name,"LoveAllowLayerDeletion")==0) return LoveAllowLayerDeletionEnum; - else if (strcmp(name,"LoveForcingType")==0) return LoveForcingTypeEnum; - else if (strcmp(name,"LoveFrequencies")==0) return LoveFrequenciesEnum; - else if (strcmp(name,"LoveG0")==0) return LoveG0Enum; - else if (strcmp(name,"LoveKernels")==0) return LoveKernelsEnum; - else if (strcmp(name,"LoveMu0")==0) return LoveMu0Enum; - else if (strcmp(name,"LoveNfreq")==0) return LoveNfreqEnum; - else if (strcmp(name,"LoveR0")==0) return LoveR0Enum; - else if (strcmp(name,"LoveShNmax")==0) return LoveShNmaxEnum; - else if (strcmp(name,"LoveShNmin")==0) return LoveShNminEnum; - else if (strcmp(name,"MassFluxSegments")==0) return MassFluxSegmentsEnum; - else if (strcmp(name,"MassFluxSegmentsPresent")==0) return MassFluxSegmentsPresentEnum; - else if (strcmp(name,"MasstransportHydrostaticAdjustment")==0) return MasstransportHydrostaticAdjustmentEnum; - else if (strcmp(name,"MasstransportIsfreesurface")==0) return MasstransportIsfreesurfaceEnum; - else if (strcmp(name,"MasstransportMinThickness")==0) return MasstransportMinThicknessEnum; - else if (strcmp(name,"MasstransportNumRequestedOutputs")==0) return MasstransportNumRequestedOutputsEnum; - else if (strcmp(name,"MasstransportPenaltyFactor")==0) return MasstransportPenaltyFactorEnum; - else if (strcmp(name,"MasstransportRequestedOutputs")==0) return MasstransportRequestedOutputsEnum; - else if (strcmp(name,"MasstransportStabilization")==0) return MasstransportStabilizationEnum; - else if (strcmp(name,"MaterialsBeta")==0) return MaterialsBetaEnum; - else if (strcmp(name,"MaterialsEarthDensity")==0) return MaterialsEarthDensityEnum; - else if (strcmp(name,"MaterialsEffectiveconductivityAveraging")==0) return MaterialsEffectiveconductivityAveragingEnum; - else if (strcmp(name,"MaterialsHeatcapacity")==0) return MaterialsHeatcapacityEnum; - else if (strcmp(name,"MaterialsLatentheat")==0) return MaterialsLatentheatEnum; - else if (strcmp(name,"MaterialsLithosphereDensity")==0) return MaterialsLithosphereDensityEnum; - else if (strcmp(name,"MaterialsLithosphereShearModulus")==0) return MaterialsLithosphereShearModulusEnum; - else if (strcmp(name,"MaterialsMantleDensity")==0) return MaterialsMantleDensityEnum; - else if (strcmp(name,"MaterialsMantleShearModulus")==0) return MaterialsMantleShearModulusEnum; - else if (strcmp(name,"MaterialsMeltingpoint")==0) return MaterialsMeltingpointEnum; - else if (strcmp(name,"MaterialsMixedLayerCapacity")==0) return MaterialsMixedLayerCapacityEnum; - else if (strcmp(name,"MaterialsMuWater")==0) return MaterialsMuWaterEnum; - else stage=3; - } - if(stage==3){ - if (strcmp(name,"MaterialsRheologyLaw")==0) return MaterialsRheologyLawEnum; - else if (strcmp(name,"MaterialsRhoFreshwater")==0) return MaterialsRhoFreshwaterEnum; - else if (strcmp(name,"MaterialsRhoIce")==0) return MaterialsRhoIceEnum; - else if (strcmp(name,"MaterialsRhoSeawater")==0) return MaterialsRhoSeawaterEnum; - else if (strcmp(name,"MaterialsTemperateiceconductivity")==0) return MaterialsTemperateiceconductivityEnum; - else if (strcmp(name,"MaterialsThermalExchangeVelocity")==0) return MaterialsThermalExchangeVelocityEnum; - else if (strcmp(name,"MaterialsThermalconductivity")==0) return MaterialsThermalconductivityEnum; - else if (strcmp(name,"MeltingOffset")==0) return MeltingOffsetEnum; - else if (strcmp(name,"MeshAverageVertexConnectivity")==0) return MeshAverageVertexConnectivityEnum; - else if (strcmp(name,"MeshElementtype")==0) return MeshElementtypeEnum; - else if (strcmp(name,"MeshNumberoflayers")==0) return MeshNumberoflayersEnum; - else if (strcmp(name,"MeshNumberofvertices")==0) return MeshNumberofverticesEnum; - else if (strcmp(name,"ModelId")==0) return ModelIdEnum; - else if (strcmp(name,"Nodes")==0) return NodesEnum; - else if (strcmp(name,"NumModels")==0) return NumModelsEnum; - else if (strcmp(name,"OceanGridNx")==0) return OceanGridNxEnum; - else if (strcmp(name,"OceanGridNy")==0) return OceanGridNyEnum; - else if (strcmp(name,"OceanGridX")==0) return OceanGridXEnum; - else if (strcmp(name,"OceanGridY")==0) return OceanGridYEnum; - else if (strcmp(name,"OutputBufferPointer")==0) return OutputBufferPointerEnum; - else if (strcmp(name,"OutputBufferSizePointer")==0) return OutputBufferSizePointerEnum; - else if (strcmp(name,"OutputFileName")==0) return OutputFileNameEnum; - else if (strcmp(name,"OutputFilePointer")==0) return OutputFilePointerEnum; - else if (strcmp(name,"Outputdefinition")==0) return OutputdefinitionEnum; - else if (strcmp(name,"Param")==0) return ParamEnum; - else if (strcmp(name,"Parameters")==0) return ParametersEnum; - else if (strcmp(name,"QmuErrName")==0) return QmuErrNameEnum; - else if (strcmp(name,"QmuInName")==0) return QmuInNameEnum; - else if (strcmp(name,"QmuIsdakota")==0) return QmuIsdakotaEnum; - else if (strcmp(name,"QmuNumberofpartitions")==0) return QmuNumberofpartitionsEnum; - else if (strcmp(name,"QmuOutName")==0) return QmuOutNameEnum; - else if (strcmp(name,"QmuPartition")==0) return QmuPartitionEnum; - else if (strcmp(name,"QmuResponsedescriptors")==0) return QmuResponsedescriptorsEnum; - else if (strcmp(name,"QmuVariableDescriptors")==0) return QmuVariableDescriptorsEnum; - else if (strcmp(name,"RestartFileName")==0) return RestartFileNameEnum; - else if (strcmp(name,"Results")==0) return ResultsEnum; - else if (strcmp(name,"RootPath")==0) return RootPathEnum; - else if (strcmp(name,"SaveResults")==0) return SaveResultsEnum; - else if (strcmp(name,"SealevelEustatic")==0) return SealevelEustaticEnum; - else if (strcmp(name,"SealevelriseAbstol")==0) return SealevelriseAbstolEnum; - else if (strcmp(name,"SealevelriseAngularVelocity")==0) return SealevelriseAngularVelocityEnum; - else if (strcmp(name,"SealevelriseElastic")==0) return SealevelriseElasticEnum; - else if (strcmp(name,"SealevelriseEquatorialMoi")==0) return SealevelriseEquatorialMoiEnum; - else if (strcmp(name,"SealevelriseFluidLove")==0) return SealevelriseFluidLoveEnum; - else if (strcmp(name,"SealevelriseGElastic")==0) return SealevelriseGElasticEnum; - else if (strcmp(name,"SealevelriseGeodetic")==0) return SealevelriseGeodeticEnum; - else if (strcmp(name,"SealevelriseGeodeticRunFrequency")==0) return SealevelriseGeodeticRunFrequencyEnum; - else if (strcmp(name,"SealevelriseHElastic")==0) return SealevelriseHElasticEnum; - else if (strcmp(name,"SealevelriseHoriz")==0) return SealevelriseHorizEnum; - else if (strcmp(name,"SealevelriseLoopIncrement")==0) return SealevelriseLoopIncrementEnum; - else if (strcmp(name,"SealevelriseMaxiter")==0) return SealevelriseMaxiterEnum; - else if (strcmp(name,"SealevelriseOceanAreaScaling")==0) return SealevelriseOceanAreaScalingEnum; - else if (strcmp(name,"SealevelrisePolarMoi")==0) return SealevelrisePolarMoiEnum; - else if (strcmp(name,"SealevelriseReltol")==0) return SealevelriseReltolEnum; - else if (strcmp(name,"SealevelriseRequestedOutputs")==0) return SealevelriseRequestedOutputsEnum; - else if (strcmp(name,"SealevelriseRigid")==0) return SealevelriseRigidEnum; - else if (strcmp(name,"SealevelriseRotation")==0) return SealevelriseRotationEnum; - else if (strcmp(name,"SealevelriseRunCount")==0) return SealevelriseRunCountEnum; - else if (strcmp(name,"SealevelriseTidalLoveH")==0) return SealevelriseTidalLoveHEnum; - else if (strcmp(name,"SealevelriseTidalLoveK")==0) return SealevelriseTidalLoveKEnum; - else if (strcmp(name,"SealevelriseTransitions")==0) return SealevelriseTransitionsEnum; - else if (strcmp(name,"SealevelriseUElastic")==0) return SealevelriseUElasticEnum; - else if (strcmp(name,"SettingsIoGather")==0) return SettingsIoGatherEnum; - else if (strcmp(name,"SettingsNumResultsOnNodes")==0) return SettingsNumResultsOnNodesEnum; - else if (strcmp(name,"SettingsOutputFrequency")==0) return SettingsOutputFrequencyEnum; - else if (strcmp(name,"SettingsRecordingFrequency")==0) return SettingsRecordingFrequencyEnum; - else if (strcmp(name,"SettingsResultsOnNodes")==0) return SettingsResultsOnNodesEnum; - else if (strcmp(name,"SettingsSbCouplingFrequency")==0) return SettingsSbCouplingFrequencyEnum; - else if (strcmp(name,"SettingsSolverResidueThreshold")==0) return SettingsSolverResidueThresholdEnum; - else if (strcmp(name,"SettingsWaitonlock")==0) return SettingsWaitonlockEnum; - else if (strcmp(name,"SmbAIce")==0) return SmbAIceEnum; - else if (strcmp(name,"SmbAIdx")==0) return SmbAIdxEnum; - else if (strcmp(name,"SmbASnow")==0) return SmbASnowEnum; - else if (strcmp(name,"SmbAccualti")==0) return SmbAccualtiEnum; - else if (strcmp(name,"SmbAccugrad")==0) return SmbAccugradEnum; - else if (strcmp(name,"SmbAccuref")==0) return SmbAccurefEnum; - else if (strcmp(name,"SmbAdThresh")==0) return SmbAdThreshEnum; - else if (strcmp(name,"SmbCldFrac")==0) return SmbCldFracEnum; - else if (strcmp(name,"SmbDelta18o")==0) return SmbDelta18oEnum; - else if (strcmp(name,"SmbDelta18oSurface")==0) return SmbDelta18oSurfaceEnum; - else if (strcmp(name,"SmbDenIdx")==0) return SmbDenIdxEnum; - else if (strcmp(name,"SmbDesfac")==0) return SmbDesfacEnum; - else if (strcmp(name,"SmbDpermil")==0) return SmbDpermilEnum; - else if (strcmp(name,"SmbDsnowIdx")==0) return SmbDsnowIdxEnum; - else if (strcmp(name,"SmbDt")==0) return SmbDtEnum; - else if (strcmp(name,"Smb")==0) return SmbEnum; - else if (strcmp(name,"SmbF")==0) return SmbFEnum; - else if (strcmp(name,"SmbInitDensityScaling")==0) return SmbInitDensityScalingEnum; - else if (strcmp(name,"SmbIsaccumulation")==0) return SmbIsaccumulationEnum; - else if (strcmp(name,"SmbIsalbedo")==0) return SmbIsalbedoEnum; - else if (strcmp(name,"SmbIsclimatology")==0) return SmbIsclimatologyEnum; - else if (strcmp(name,"SmbIsd18opd")==0) return SmbIsd18opdEnum; - else if (strcmp(name,"SmbIsdelta18o")==0) return SmbIsdelta18oEnum; - else if (strcmp(name,"SmbIsdensification")==0) return SmbIsdensificationEnum; - else if (strcmp(name,"SmbIsfirnwarming")==0) return SmbIsfirnwarmingEnum; - else if (strcmp(name,"SmbIsgraingrowth")==0) return SmbIsgraingrowthEnum; - else if (strcmp(name,"SmbIsmelt")==0) return SmbIsmeltEnum; - else if (strcmp(name,"SmbIsmungsm")==0) return SmbIsmungsmEnum; - else if (strcmp(name,"SmbIsprecipscaled")==0) return SmbIsprecipscaledEnum; - else if (strcmp(name,"SmbIssetpddfac")==0) return SmbIssetpddfacEnum; - else if (strcmp(name,"SmbIsshortwave")==0) return SmbIsshortwaveEnum; - else if (strcmp(name,"SmbIstemperaturescaled")==0) return SmbIstemperaturescaledEnum; - else if (strcmp(name,"SmbIsthermal")==0) return SmbIsthermalEnum; - else if (strcmp(name,"SmbIsturbulentflux")==0) return SmbIsturbulentfluxEnum; - else if (strcmp(name,"SmbK")==0) return SmbKEnum; - else if (strcmp(name,"SmbNumRequestedOutputs")==0) return SmbNumRequestedOutputsEnum; - else if (strcmp(name,"SmbPfac")==0) return SmbPfacEnum; - else if (strcmp(name,"SmbRdl")==0) return SmbRdlEnum; - else if (strcmp(name,"SmbRequestedOutputs")==0) return SmbRequestedOutputsEnum; - else if (strcmp(name,"SmbRlaps")==0) return SmbRlapsEnum; - else if (strcmp(name,"SmbRlapslgm")==0) return SmbRlapslgmEnum; - else if (strcmp(name,"SmbRunoffalti")==0) return SmbRunoffaltiEnum; - else if (strcmp(name,"SmbRunoffgrad")==0) return SmbRunoffgradEnum; - else if (strcmp(name,"SmbRunoffref")==0) return SmbRunoffrefEnum; - else if (strcmp(name,"SmbSealev")==0) return SmbSealevEnum; - else if (strcmp(name,"SmbSwIdx")==0) return SmbSwIdxEnum; - else if (strcmp(name,"SmbT0dry")==0) return SmbT0dryEnum; - else if (strcmp(name,"SmbT0wet")==0) return SmbT0wetEnum; - else if (strcmp(name,"SmbTdiff")==0) return SmbTdiffEnum; - else if (strcmp(name,"SmbThermoDeltaTScaling")==0) return SmbThermoDeltaTScalingEnum; - else stage=4; - } - if(stage==4){ - if (strcmp(name,"SmoothThicknessMultiplier")==0) return SmoothThicknessMultiplierEnum; - else if (strcmp(name,"SolutionType")==0) return SolutionTypeEnum; - else if (strcmp(name,"SteadystateMaxiter")==0) return SteadystateMaxiterEnum; - else if (strcmp(name,"SteadystateNumRequestedOutputs")==0) return SteadystateNumRequestedOutputsEnum; - else if (strcmp(name,"SteadystateReltol")==0) return SteadystateReltolEnum; - else if (strcmp(name,"SteadystateRequestedOutputs")==0) return SteadystateRequestedOutputsEnum; - else if (strcmp(name,"Step")==0) return StepEnum; - else if (strcmp(name,"StressbalanceAbstol")==0) return StressbalanceAbstolEnum; - else if (strcmp(name,"StressbalanceFSreconditioning")==0) return StressbalanceFSreconditioningEnum; - else if (strcmp(name,"StressbalanceIsnewton")==0) return StressbalanceIsnewtonEnum; - else if (strcmp(name,"StressbalanceMaxiter")==0) return StressbalanceMaxiterEnum; - else if (strcmp(name,"StressbalanceNumRequestedOutputs")==0) return StressbalanceNumRequestedOutputsEnum; - else if (strcmp(name,"StressbalancePenaltyFactor")==0) return StressbalancePenaltyFactorEnum; - else if (strcmp(name,"StressbalanceReltol")==0) return StressbalanceReltolEnum; - else if (strcmp(name,"StressbalanceRequestedOutputs")==0) return StressbalanceRequestedOutputsEnum; - else if (strcmp(name,"StressbalanceRestol")==0) return StressbalanceRestolEnum; - else if (strcmp(name,"StressbalanceRiftPenaltyThreshold")==0) return StressbalanceRiftPenaltyThresholdEnum; - else if (strcmp(name,"StressbalanceShelfDampening")==0) return StressbalanceShelfDampeningEnum; - else if (strcmp(name,"ThermalIsdynamicbasalspc")==0) return ThermalIsdynamicbasalspcEnum; - else if (strcmp(name,"ThermalIsenthalpy")==0) return ThermalIsenthalpyEnum; - else if (strcmp(name,"ThermalMaxiter")==0) return ThermalMaxiterEnum; - else if (strcmp(name,"ThermalNumRequestedOutputs")==0) return ThermalNumRequestedOutputsEnum; - else if (strcmp(name,"ThermalPenaltyFactor")==0) return ThermalPenaltyFactorEnum; - else if (strcmp(name,"ThermalPenaltyLock")==0) return ThermalPenaltyLockEnum; - else if (strcmp(name,"ThermalPenaltyThreshold")==0) return ThermalPenaltyThresholdEnum; - else if (strcmp(name,"ThermalReltol")==0) return ThermalReltolEnum; - else if (strcmp(name,"ThermalRequestedOutputs")==0) return ThermalRequestedOutputsEnum; - else if (strcmp(name,"ThermalStabilization")==0) return ThermalStabilizationEnum; - else if (strcmp(name,"Time")==0) return TimeEnum; - else if (strcmp(name,"TimesteppingCflCoefficient")==0) return TimesteppingCflCoefficientEnum; - else if (strcmp(name,"TimesteppingCouplingTime")==0) return TimesteppingCouplingTimeEnum; - else if (strcmp(name,"TimesteppingFinalTime")==0) return TimesteppingFinalTimeEnum; - else if (strcmp(name,"TimesteppingInterpForcings")==0) return TimesteppingInterpForcingsEnum; - else if (strcmp(name,"TimesteppingStartTime")==0) return TimesteppingStartTimeEnum; - else if (strcmp(name,"TimesteppingTimeStep")==0) return TimesteppingTimeStepEnum; - else if (strcmp(name,"TimesteppingTimeStepMax")==0) return TimesteppingTimeStepMaxEnum; - else if (strcmp(name,"TimesteppingTimeStepMin")==0) return TimesteppingTimeStepMinEnum; - else if (strcmp(name,"TimesteppingType")==0) return TimesteppingTypeEnum; - else if (strcmp(name,"ToMITgcmComm")==0) return ToMITgcmCommEnum; - else if (strcmp(name,"ToolkitsFileName")==0) return ToolkitsFileNameEnum; - else if (strcmp(name,"ToolkitsOptionsAnalyses")==0) return ToolkitsOptionsAnalysesEnum; - else if (strcmp(name,"ToolkitsOptionsStrings")==0) return ToolkitsOptionsStringsEnum; - else if (strcmp(name,"ToolkitsTypes")==0) return ToolkitsTypesEnum; - else if (strcmp(name,"TransientAmrFrequency")==0) return TransientAmrFrequencyEnum; - else if (strcmp(name,"TransientIscoupler")==0) return TransientIscouplerEnum; - else if (strcmp(name,"TransientIsdamageevolution")==0) return TransientIsdamageevolutionEnum; - else if (strcmp(name,"TransientIsesa")==0) return TransientIsesaEnum; - else if (strcmp(name,"TransientIsgia")==0) return TransientIsgiaEnum; - else if (strcmp(name,"TransientIsgroundingline")==0) return TransientIsgroundinglineEnum; - else if (strcmp(name,"TransientIshydrology")==0) return TransientIshydrologyEnum; - else if (strcmp(name,"TransientIsmasstransport")==0) return TransientIsmasstransportEnum; - else if (strcmp(name,"TransientIsmovingfront")==0) return TransientIsmovingfrontEnum; - else if (strcmp(name,"TransientIsoceancoupling")==0) return TransientIsoceancouplingEnum; - else if (strcmp(name,"TransientIsslr")==0) return TransientIsslrEnum; - else if (strcmp(name,"TransientIssmb")==0) return TransientIssmbEnum; - else if (strcmp(name,"TransientIsstressbalance")==0) return TransientIsstressbalanceEnum; - else if (strcmp(name,"TransientIsthermal")==0) return TransientIsthermalEnum; - else if (strcmp(name,"TransientNumRequestedOutputs")==0) return TransientNumRequestedOutputsEnum; - else if (strcmp(name,"TransientRequestedOutputs")==0) return TransientRequestedOutputsEnum; - else if (strcmp(name,"Velocity")==0) return VelocityEnum; - else if (strcmp(name,"WorldComm")==0) return WorldCommEnum; - else if (strcmp(name,"ParametersEND")==0) return ParametersENDEnum; - else if (strcmp(name,"InputsSTART")==0) return InputsSTARTEnum; - else if (strcmp(name,"Adjoint")==0) return AdjointEnum; - else if (strcmp(name,"Adjointp")==0) return AdjointpEnum; - else if (strcmp(name,"Adjointx")==0) return AdjointxEnum; - else if (strcmp(name,"Adjointy")==0) return AdjointyEnum; - else if (strcmp(name,"Adjointz")==0) return AdjointzEnum; - else if (strcmp(name,"Air")==0) return AirEnum; - else if (strcmp(name,"Approximation")==0) return ApproximationEnum; - else if (strcmp(name,"BalancethicknessMisfit")==0) return BalancethicknessMisfitEnum; - else if (strcmp(name,"BalancethicknessOmega0")==0) return BalancethicknessOmega0Enum; - else if (strcmp(name,"BalancethicknessOmega")==0) return BalancethicknessOmegaEnum; - else if (strcmp(name,"BalancethicknessThickeningRate")==0) return BalancethicknessThickeningRateEnum; - else if (strcmp(name,"BasalCrevasse")==0) return BasalCrevasseEnum; - else if (strcmp(name,"BasalforcingsFloatingiceMeltingRate")==0) return BasalforcingsFloatingiceMeltingRateEnum; - else if (strcmp(name,"BasalforcingsGeothermalflux")==0) return BasalforcingsGeothermalfluxEnum; - else if (strcmp(name,"BasalforcingsGroundediceMeltingRate")==0) return BasalforcingsGroundediceMeltingRateEnum; - else if (strcmp(name,"BasalforcingsIsmp6BasinId")==0) return BasalforcingsIsmp6BasinIdEnum; - else if (strcmp(name,"BasalforcingsIsmp6Tf")==0) return BasalforcingsIsmp6TfEnum; - else if (strcmp(name,"BasalforcingsIsmp6TfShelf")==0) return BasalforcingsIsmp6TfShelfEnum; - else if (strcmp(name,"BasalforcingsPicoBasinId")==0) return BasalforcingsPicoBasinIdEnum; - else if (strcmp(name,"BasalforcingsPicoBoxId")==0) return BasalforcingsPicoBoxIdEnum; - else if (strcmp(name,"BasalforcingsPicoSubShelfOceanOverturning")==0) return BasalforcingsPicoSubShelfOceanOverturningEnum; - else if (strcmp(name,"BasalforcingsPicoSubShelfOceanSalinity")==0) return BasalforcingsPicoSubShelfOceanSalinityEnum; - else if (strcmp(name,"BasalforcingsPicoSubShelfOceanTemp")==0) return BasalforcingsPicoSubShelfOceanTempEnum; - else if (strcmp(name,"Base")==0) return BaseEnum; - else if (strcmp(name,"BaseSlopeX")==0) return BaseSlopeXEnum; - else if (strcmp(name,"BaseSlopeY")==0) return BaseSlopeYEnum; - else if (strcmp(name,"Bed")==0) return BedEnum; - else if (strcmp(name,"BedSlopeX")==0) return BedSlopeXEnum; - else if (strcmp(name,"BedSlopeY")==0) return BedSlopeYEnum; - else if (strcmp(name,"CalvingCalvingrate")==0) return CalvingCalvingrateEnum; - else if (strcmp(name,"CalvingHabFraction")==0) return CalvingHabFractionEnum; - else if (strcmp(name,"CalvingMeltingrate")==0) return CalvingMeltingrateEnum; - else if (strcmp(name,"CalvingStressThresholdFloatingice")==0) return CalvingStressThresholdFloatingiceEnum; - else if (strcmp(name,"CalvingStressThresholdGroundedice")==0) return CalvingStressThresholdGroundediceEnum; - else if (strcmp(name,"CalvinglevermannCoeff")==0) return CalvinglevermannCoeffEnum; - else if (strcmp(name,"CalvingratexAverage")==0) return CalvingratexAverageEnum; - else if (strcmp(name,"Calvingratex")==0) return CalvingratexEnum; - else if (strcmp(name,"CalvingrateyAverage")==0) return CalvingrateyAverageEnum; - else if (strcmp(name,"Calvingratey")==0) return CalvingrateyEnum; - else if (strcmp(name,"Converged")==0) return ConvergedEnum; - else if (strcmp(name,"CrevasseDepth")==0) return CrevasseDepthEnum; - else if (strcmp(name,"DamageD")==0) return DamageDEnum; - else if (strcmp(name,"DamageDbar")==0) return DamageDbarEnum; - else if (strcmp(name,"DamageF")==0) return DamageFEnum; - else if (strcmp(name,"DegreeOfChannelization")==0) return DegreeOfChannelizationEnum; - else if (strcmp(name,"DeviatoricStresseffective")==0) return DeviatoricStresseffectiveEnum; - else if (strcmp(name,"DeviatoricStressxx")==0) return DeviatoricStressxxEnum; - else if (strcmp(name,"DeviatoricStressxy")==0) return DeviatoricStressxyEnum; - else if (strcmp(name,"DeviatoricStressxz")==0) return DeviatoricStressxzEnum; - else if (strcmp(name,"DeviatoricStressyy")==0) return DeviatoricStressyyEnum; - else if (strcmp(name,"DeviatoricStressyz")==0) return DeviatoricStressyzEnum; - else if (strcmp(name,"DeviatoricStresszz")==0) return DeviatoricStresszzEnum; - else if (strcmp(name,"DistanceToCalvingfront")==0) return DistanceToCalvingfrontEnum; - else if (strcmp(name,"DistanceToGroundingline")==0) return DistanceToGroundinglineEnum; - else if (strcmp(name,"Domain2Dhorizontal")==0) return Domain2DhorizontalEnum; - else if (strcmp(name,"Domain2Dvertical")==0) return Domain2DverticalEnum; - else if (strcmp(name,"Domain3D")==0) return Domain3DEnum; - else stage=5; - } - if(stage==5){ - if (strcmp(name,"DragCoefficientAbsGradient")==0) return DragCoefficientAbsGradientEnum; - else if (strcmp(name,"DrivingStressX")==0) return DrivingStressXEnum; - else if (strcmp(name,"DrivingStressY")==0) return DrivingStressYEnum; - else if (strcmp(name,"EffectivePressure")==0) return EffectivePressureEnum; - else if (strcmp(name,"EffectivePressureHydrostep")==0) return EffectivePressureHydrostepEnum; - else if (strcmp(name,"EffectivePressureStacked")==0) return EffectivePressureStackedEnum; - else if (strcmp(name,"Enthalpy")==0) return EnthalpyEnum; - else if (strcmp(name,"EnthalpyPicard")==0) return EnthalpyPicardEnum; - else if (strcmp(name,"EplHead")==0) return EplHeadEnum; - else if (strcmp(name,"EplHeadHydrostep")==0) return EplHeadHydrostepEnum; - else if (strcmp(name,"EplHeadOld")==0) return EplHeadOldEnum; - else if (strcmp(name,"EplHeadSlopeX")==0) return EplHeadSlopeXEnum; - else if (strcmp(name,"EplHeadSlopeY")==0) return EplHeadSlopeYEnum; - else if (strcmp(name,"EplHeadStacked")==0) return EplHeadStackedEnum; - else if (strcmp(name,"EsaDeltathickness")==0) return EsaDeltathicknessEnum; - else if (strcmp(name,"EsaEmotion")==0) return EsaEmotionEnum; - else if (strcmp(name,"EsaNmotion")==0) return EsaNmotionEnum; - else if (strcmp(name,"EsaRotationrate")==0) return EsaRotationrateEnum; - else if (strcmp(name,"EsaStrainratexx")==0) return EsaStrainratexxEnum; - else if (strcmp(name,"EsaStrainratexy")==0) return EsaStrainratexyEnum; - else if (strcmp(name,"EsaStrainrateyy")==0) return EsaStrainrateyyEnum; - else if (strcmp(name,"EsaUmotion")==0) return EsaUmotionEnum; - else if (strcmp(name,"EsaXmotion")==0) return EsaXmotionEnum; - else if (strcmp(name,"EsaYmotion")==0) return EsaYmotionEnum; - else if (strcmp(name,"EtaDiff")==0) return EtaDiffEnum; - else if (strcmp(name,"FlowequationBorderFS")==0) return FlowequationBorderFSEnum; - else if (strcmp(name,"FrictionAs")==0) return FrictionAsEnum; - else if (strcmp(name,"FrictionC")==0) return FrictionCEnum; - else if (strcmp(name,"FrictionCmax")==0) return FrictionCmaxEnum; - else if (strcmp(name,"FrictionCoefficient")==0) return FrictionCoefficientEnum; - else if (strcmp(name,"FrictionCoefficientcoulomb")==0) return FrictionCoefficientcoulombEnum; - else if (strcmp(name,"FrictionEffectivePressure")==0) return FrictionEffectivePressureEnum; - else if (strcmp(name,"FrictionM")==0) return FrictionMEnum; - else if (strcmp(name,"FrictionP")==0) return FrictionPEnum; - else if (strcmp(name,"FrictionPressureAdjustedTemperature")==0) return FrictionPressureAdjustedTemperatureEnum; - else if (strcmp(name,"FrictionQ")==0) return FrictionQEnum; - else if (strcmp(name,"FrictionSedimentCompressibilityCoefficient")==0) return FrictionSedimentCompressibilityCoefficientEnum; - else if (strcmp(name,"FrictionTillFrictionAngle")==0) return FrictionTillFrictionAngleEnum; - else if (strcmp(name,"FrictionWaterLayer")==0) return FrictionWaterLayerEnum; - else if (strcmp(name,"Frictionf")==0) return FrictionfEnum; - else if (strcmp(name,"FrontalForcingsBasinId")==0) return FrontalForcingsBasinIdEnum; - else if (strcmp(name,"FrontalForcingsSubglacialDischarge")==0) return FrontalForcingsSubglacialDischargeEnum; - else if (strcmp(name,"FrontalForcingsThermalForcing")==0) return FrontalForcingsThermalForcingEnum; - else if (strcmp(name,"GeometryHydrostaticRatio")==0) return GeometryHydrostaticRatioEnum; - else if (strcmp(name,"GiaLithosphereThickness")==0) return GiaLithosphereThicknessEnum; - else if (strcmp(name,"GiaMantleViscosity")==0) return GiaMantleViscosityEnum; - else if (strcmp(name,"GiaW")==0) return GiaWEnum; - else if (strcmp(name,"GiadWdt")==0) return GiadWdtEnum; - else if (strcmp(name,"Gradient")==0) return GradientEnum; - else if (strcmp(name,"GroundinglineHeight")==0) return GroundinglineHeightEnum; - else if (strcmp(name,"HydraulicPotential")==0) return HydraulicPotentialEnum; - else if (strcmp(name,"HydraulicPotentialOld")==0) return HydraulicPotentialOldEnum; - else if (strcmp(name,"HydrologyBasalFlux")==0) return HydrologyBasalFluxEnum; - else if (strcmp(name,"HydrologyBumpHeight")==0) return HydrologyBumpHeightEnum; - else if (strcmp(name,"HydrologyBumpSpacing")==0) return HydrologyBumpSpacingEnum; - else if (strcmp(name,"HydrologyDrainageRate")==0) return HydrologyDrainageRateEnum; - else if (strcmp(name,"HydrologyEnglacialInput")==0) return HydrologyEnglacialInputEnum; - else if (strcmp(name,"HydrologyGapHeight")==0) return HydrologyGapHeightEnum; - else if (strcmp(name,"HydrologyHead")==0) return HydrologyHeadEnum; - else if (strcmp(name,"HydrologyHeadOld")==0) return HydrologyHeadOldEnum; - else if (strcmp(name,"HydrologyMoulinInput")==0) return HydrologyMoulinInputEnum; - else if (strcmp(name,"HydrologyNeumannflux")==0) return HydrologyNeumannfluxEnum; - else if (strcmp(name,"HydrologyReynolds")==0) return HydrologyReynoldsEnum; - else if (strcmp(name,"HydrologySheetConductivity")==0) return HydrologySheetConductivityEnum; - else if (strcmp(name,"HydrologySheetThickness")==0) return HydrologySheetThicknessEnum; - else if (strcmp(name,"HydrologyWaterVx")==0) return HydrologyWaterVxEnum; - else if (strcmp(name,"HydrologyWaterVy")==0) return HydrologyWaterVyEnum; - else if (strcmp(name,"HydrologyWatercolumnMax")==0) return HydrologyWatercolumnMaxEnum; - else if (strcmp(name,"HydrologydcBasalMoulinInput")==0) return HydrologydcBasalMoulinInputEnum; - else if (strcmp(name,"HydrologydcEplThickness")==0) return HydrologydcEplThicknessEnum; - else if (strcmp(name,"HydrologydcEplThicknessHydrostep")==0) return HydrologydcEplThicknessHydrostepEnum; - else if (strcmp(name,"HydrologydcEplThicknessOld")==0) return HydrologydcEplThicknessOldEnum; - else if (strcmp(name,"HydrologydcEplThicknessStacked")==0) return HydrologydcEplThicknessStackedEnum; - else if (strcmp(name,"HydrologydcMaskEplactiveElt")==0) return HydrologydcMaskEplactiveEltEnum; - else if (strcmp(name,"HydrologydcMaskEplactiveNode")==0) return HydrologydcMaskEplactiveNodeEnum; - else if (strcmp(name,"HydrologydcMaskThawedElt")==0) return HydrologydcMaskThawedEltEnum; - else if (strcmp(name,"HydrologydcMaskThawedNode")==0) return HydrologydcMaskThawedNodeEnum; - else if (strcmp(name,"HydrologydcSedimentTransmitivity")==0) return HydrologydcSedimentTransmitivityEnum; - else if (strcmp(name,"Ice")==0) return IceEnum; - else if (strcmp(name,"IceMaskNodeActivation")==0) return IceMaskNodeActivationEnum; - else if (strcmp(name,"Input")==0) return InputEnum; - else if (strcmp(name,"InversionCostFunctionsCoefficients")==0) return InversionCostFunctionsCoefficientsEnum; - else if (strcmp(name,"InversionSurfaceObs")==0) return InversionSurfaceObsEnum; - else if (strcmp(name,"InversionThicknessObs")==0) return InversionThicknessObsEnum; - else if (strcmp(name,"InversionVelObs")==0) return InversionVelObsEnum; - else if (strcmp(name,"InversionVxObs")==0) return InversionVxObsEnum; - else if (strcmp(name,"InversionVyObs")==0) return InversionVyObsEnum; - else if (strcmp(name,"LevelsetfunctionSlopeX")==0) return LevelsetfunctionSlopeXEnum; - else if (strcmp(name,"LevelsetfunctionSlopeY")==0) return LevelsetfunctionSlopeYEnum; - else if (strcmp(name,"LoadingforceX")==0) return LoadingforceXEnum; - else if (strcmp(name,"LoadingforceY")==0) return LoadingforceYEnum; - else if (strcmp(name,"LoadingforceZ")==0) return LoadingforceZEnum; - else if (strcmp(name,"MaskGroundediceLevelset")==0) return MaskGroundediceLevelsetEnum; - else if (strcmp(name,"MaskIceLevelset")==0) return MaskIceLevelsetEnum; - else if (strcmp(name,"MaskLandLevelset")==0) return MaskLandLevelsetEnum; - else if (strcmp(name,"MaskOceanLevelset")==0) return MaskOceanLevelsetEnum; - else if (strcmp(name,"MasstransportSpcthickness")==0) return MasstransportSpcthicknessEnum; - else if (strcmp(name,"MaterialsRheologyB")==0) return MaterialsRheologyBEnum; - else if (strcmp(name,"MaterialsRheologyBbar")==0) return MaterialsRheologyBbarEnum; - else if (strcmp(name,"MaterialsRheologyE")==0) return MaterialsRheologyEEnum; - else if (strcmp(name,"MaterialsRheologyEbar")==0) return MaterialsRheologyEbarEnum; - else if (strcmp(name,"MaterialsRheologyEc")==0) return MaterialsRheologyEcEnum; - else if (strcmp(name,"MaterialsRheologyEcbar")==0) return MaterialsRheologyEcbarEnum; - else if (strcmp(name,"MaterialsRheologyEs")==0) return MaterialsRheologyEsEnum; - else if (strcmp(name,"MaterialsRheologyEsbar")==0) return MaterialsRheologyEsbarEnum; - else if (strcmp(name,"MaterialsRheologyN")==0) return MaterialsRheologyNEnum; - else if (strcmp(name,"MeshScaleFactor")==0) return MeshScaleFactorEnum; - else if (strcmp(name,"MeshVertexonbase")==0) return MeshVertexonbaseEnum; - else if (strcmp(name,"MeshVertexonboundary")==0) return MeshVertexonboundaryEnum; - else if (strcmp(name,"MeshVertexonsurface")==0) return MeshVertexonsurfaceEnum; - else if (strcmp(name,"Misfit")==0) return MisfitEnum; - else if (strcmp(name,"Neumannflux")==0) return NeumannfluxEnum; - else if (strcmp(name,"NewDamage")==0) return NewDamageEnum; - else if (strcmp(name,"Node")==0) return NodeEnum; - else if (strcmp(name,"OmegaAbsGradient")==0) return OmegaAbsGradientEnum; - else if (strcmp(name,"P0")==0) return P0Enum; - else if (strcmp(name,"P1")==0) return P1Enum; - else if (strcmp(name,"Pressure")==0) return PressureEnum; - else if (strcmp(name,"RheologyBAbsGradient")==0) return RheologyBAbsGradientEnum; - else if (strcmp(name,"RheologyBInitialguess")==0) return RheologyBInitialguessEnum; - else stage=6; - } - if(stage==6){ - if (strcmp(name,"RheologyBInitialguessMisfit")==0) return RheologyBInitialguessMisfitEnum; - else if (strcmp(name,"RheologyBbarAbsGradient")==0) return RheologyBbarAbsGradientEnum; - else if (strcmp(name,"Sealevel")==0) return SealevelEnum; - else if (strcmp(name,"SealevelEustaticMask")==0) return SealevelEustaticMaskEnum; - else if (strcmp(name,"SealevelEustaticOceanMask")==0) return SealevelEustaticOceanMaskEnum; - else if (strcmp(name,"SealevelNEsa")==0) return SealevelNEsaEnum; - else if (strcmp(name,"SealevelNEsaRate")==0) return SealevelNEsaRateEnum; - else if (strcmp(name,"SealevelNGia")==0) return SealevelNGiaEnum; - else if (strcmp(name,"SealevelNGiaRate")==0) return SealevelNGiaRateEnum; - else if (strcmp(name,"SealevelRSL")==0) return SealevelRSLEnum; - else if (strcmp(name,"SealevelRSLEustatic")==0) return SealevelRSLEustaticEnum; - else if (strcmp(name,"SealevelRSLEustaticRate")==0) return SealevelRSLEustaticRateEnum; - else if (strcmp(name,"SealevelRSLRate")==0) return SealevelRSLRateEnum; - else if (strcmp(name,"SealevelUEastEsa")==0) return SealevelUEastEsaEnum; - else if (strcmp(name,"SealevelUEsa")==0) return SealevelUEsaEnum; - else if (strcmp(name,"SealevelUEsaRate")==0) return SealevelUEsaRateEnum; - else if (strcmp(name,"SealevelUGia")==0) return SealevelUGiaEnum; - else if (strcmp(name,"SealevelUGiaRate")==0) return SealevelUGiaRateEnum; - else if (strcmp(name,"SealevelUNorthEsa")==0) return SealevelUNorthEsaEnum; - else if (strcmp(name,"SealevelriseCumDeltathickness")==0) return SealevelriseCumDeltathicknessEnum; - else if (strcmp(name,"SealevelriseDeltathickness")==0) return SealevelriseDeltathicknessEnum; - else if (strcmp(name,"SealevelriseSpcthickness")==0) return SealevelriseSpcthicknessEnum; - else if (strcmp(name,"SealevelriseStericRate")==0) return SealevelriseStericRateEnum; - else if (strcmp(name,"SedimentHead")==0) return SedimentHeadEnum; - else if (strcmp(name,"SedimentHeadHydrostep")==0) return SedimentHeadHydrostepEnum; - else if (strcmp(name,"SedimentHeadOld")==0) return SedimentHeadOldEnum; - else if (strcmp(name,"SedimentHeadResidual")==0) return SedimentHeadResidualEnum; - else if (strcmp(name,"SedimentHeadStacked")==0) return SedimentHeadStackedEnum; - else if (strcmp(name,"SigmaNN")==0) return SigmaNNEnum; - else if (strcmp(name,"SigmaVM")==0) return SigmaVMEnum; - else if (strcmp(name,"SmbA")==0) return SmbAEnum; - else if (strcmp(name,"SmbAValue")==0) return SmbAValueEnum; - else if (strcmp(name,"SmbAccumulation")==0) return SmbAccumulationEnum; - else if (strcmp(name,"SmbAini")==0) return SmbAiniEnum; - else if (strcmp(name,"SmbBMax")==0) return SmbBMaxEnum; - else if (strcmp(name,"SmbBMin")==0) return SmbBMinEnum; - else if (strcmp(name,"SmbBNeg")==0) return SmbBNegEnum; - else if (strcmp(name,"SmbBPos")==0) return SmbBPosEnum; - else if (strcmp(name,"SmbC")==0) return SmbCEnum; - else if (strcmp(name,"SmbD")==0) return SmbDEnum; - else if (strcmp(name,"SmbDailyairdensity")==0) return SmbDailyairdensityEnum; - else if (strcmp(name,"SmbDailyairhumidity")==0) return SmbDailyairhumidityEnum; - else if (strcmp(name,"SmbDailydlradiation")==0) return SmbDailydlradiationEnum; - else if (strcmp(name,"SmbDailydsradiation")==0) return SmbDailydsradiationEnum; - else if (strcmp(name,"SmbDailypressure")==0) return SmbDailypressureEnum; - else if (strcmp(name,"SmbDailyrainfall")==0) return SmbDailyrainfallEnum; - else if (strcmp(name,"SmbDailysnowfall")==0) return SmbDailysnowfallEnum; - else if (strcmp(name,"SmbDailytemperature")==0) return SmbDailytemperatureEnum; - else if (strcmp(name,"SmbDailywindspeed")==0) return SmbDailywindspeedEnum; - else if (strcmp(name,"SmbDini")==0) return SmbDiniEnum; - else if (strcmp(name,"SmbDlwrf")==0) return SmbDlwrfEnum; - else if (strcmp(name,"SmbDswrf")==0) return SmbDswrfEnum; - else if (strcmp(name,"SmbDzAdd")==0) return SmbDzAddEnum; - else if (strcmp(name,"SmbDz")==0) return SmbDzEnum; - else if (strcmp(name,"SmbDzMin")==0) return SmbDzMinEnum; - else if (strcmp(name,"SmbDzTop")==0) return SmbDzTopEnum; - else if (strcmp(name,"SmbDzini")==0) return SmbDziniEnum; - else if (strcmp(name,"SmbEAir")==0) return SmbEAirEnum; - else if (strcmp(name,"SmbEC")==0) return SmbECEnum; - else if (strcmp(name,"SmbECini")==0) return SmbECiniEnum; - else if (strcmp(name,"SmbEla")==0) return SmbElaEnum; - else if (strcmp(name,"SmbEvaporation")==0) return SmbEvaporationEnum; - else if (strcmp(name,"SmbFAC")==0) return SmbFACEnum; - else if (strcmp(name,"SmbGdn")==0) return SmbGdnEnum; - else if (strcmp(name,"SmbGdnini")==0) return SmbGdniniEnum; - else if (strcmp(name,"SmbGsp")==0) return SmbGspEnum; - else if (strcmp(name,"SmbGspini")==0) return SmbGspiniEnum; - else if (strcmp(name,"SmbHref")==0) return SmbHrefEnum; - else if (strcmp(name,"SmbIsInitialized")==0) return SmbIsInitializedEnum; - else if (strcmp(name,"SmbMAdd")==0) return SmbMAddEnum; - else if (strcmp(name,"SmbMassBalanceClimate")==0) return SmbMassBalanceClimateEnum; - else if (strcmp(name,"SmbMassBalance")==0) return SmbMassBalanceEnum; - else if (strcmp(name,"SmbMeanLHF")==0) return SmbMeanLHFEnum; - else if (strcmp(name,"SmbMeanSHF")==0) return SmbMeanSHFEnum; - else if (strcmp(name,"SmbMeanULW")==0) return SmbMeanULWEnum; - else if (strcmp(name,"SmbMelt")==0) return SmbMeltEnum; - else if (strcmp(name,"SmbMonthlytemperatures")==0) return SmbMonthlytemperaturesEnum; - else if (strcmp(name,"SmbNetLW")==0) return SmbNetLWEnum; - else if (strcmp(name,"SmbNetSW")==0) return SmbNetSWEnum; - else if (strcmp(name,"SmbPAir")==0) return SmbPAirEnum; - else if (strcmp(name,"SmbP")==0) return SmbPEnum; - else if (strcmp(name,"SmbPddfacIce")==0) return SmbPddfacIceEnum; - else if (strcmp(name,"SmbPddfacSnow")==0) return SmbPddfacSnowEnum; - else if (strcmp(name,"SmbPrecipitation")==0) return SmbPrecipitationEnum; - else if (strcmp(name,"SmbPrecipitationsAnomaly")==0) return SmbPrecipitationsAnomalyEnum; - else if (strcmp(name,"SmbPrecipitationsLgm")==0) return SmbPrecipitationsLgmEnum; - else if (strcmp(name,"SmbPrecipitationsPresentday")==0) return SmbPrecipitationsPresentdayEnum; - else if (strcmp(name,"SmbPrecipitationsReconstructed")==0) return SmbPrecipitationsReconstructedEnum; - else if (strcmp(name,"SmbRe")==0) return SmbReEnum; - else if (strcmp(name,"SmbRefreeze")==0) return SmbRefreezeEnum; - else if (strcmp(name,"SmbReini")==0) return SmbReiniEnum; - else if (strcmp(name,"SmbRunoff")==0) return SmbRunoffEnum; - else if (strcmp(name,"SmbS0gcm")==0) return SmbS0gcmEnum; - else if (strcmp(name,"SmbS0p")==0) return SmbS0pEnum; - else if (strcmp(name,"SmbS0t")==0) return SmbS0tEnum; - else if (strcmp(name,"SmbSizeini")==0) return SmbSizeiniEnum; - else if (strcmp(name,"SmbSmbCorr")==0) return SmbSmbCorrEnum; - else if (strcmp(name,"SmbSmbref")==0) return SmbSmbrefEnum; - else if (strcmp(name,"SmbT")==0) return SmbTEnum; - else if (strcmp(name,"SmbTa")==0) return SmbTaEnum; - else if (strcmp(name,"SmbTeValue")==0) return SmbTeValueEnum; - else if (strcmp(name,"SmbTemperaturesAnomaly")==0) return SmbTemperaturesAnomalyEnum; - else if (strcmp(name,"SmbTemperaturesLgm")==0) return SmbTemperaturesLgmEnum; - else if (strcmp(name,"SmbTemperaturesPresentday")==0) return SmbTemperaturesPresentdayEnum; - else if (strcmp(name,"SmbTemperaturesReconstructed")==0) return SmbTemperaturesReconstructedEnum; - else if (strcmp(name,"SmbTini")==0) return SmbTiniEnum; - else if (strcmp(name,"SmbTmean")==0) return SmbTmeanEnum; - else if (strcmp(name,"SmbTz")==0) return SmbTzEnum; - else if (strcmp(name,"SmbV")==0) return SmbVEnum; - else if (strcmp(name,"SmbVmean")==0) return SmbVmeanEnum; - else if (strcmp(name,"SmbVz")==0) return SmbVzEnum; - else if (strcmp(name,"SmbW")==0) return SmbWEnum; - else if (strcmp(name,"SmbWini")==0) return SmbWiniEnum; - else if (strcmp(name,"SmbZMax")==0) return SmbZMaxEnum; - else if (strcmp(name,"SmbZMin")==0) return SmbZMinEnum; - else if (strcmp(name,"SmbZTop")==0) return SmbZTopEnum; - else if (strcmp(name,"SmbZY")==0) return SmbZYEnum; - else if (strcmp(name,"StrainRateeffective")==0) return StrainRateeffectiveEnum; - else if (strcmp(name,"StrainRateparallel")==0) return StrainRateparallelEnum; - else if (strcmp(name,"StrainRateperpendicular")==0) return StrainRateperpendicularEnum; - else stage=7; - } - if(stage==7){ - if (strcmp(name,"StrainRatexx")==0) return StrainRatexxEnum; - else if (strcmp(name,"StrainRatexy")==0) return StrainRatexyEnum; - else if (strcmp(name,"StrainRatexz")==0) return StrainRatexzEnum; - else if (strcmp(name,"StrainRateyy")==0) return StrainRateyyEnum; - else if (strcmp(name,"StrainRateyz")==0) return StrainRateyzEnum; - else if (strcmp(name,"StrainRatezz")==0) return StrainRatezzEnum; - else if (strcmp(name,"StressMaxPrincipal")==0) return StressMaxPrincipalEnum; - else if (strcmp(name,"StressTensorxx")==0) return StressTensorxxEnum; - else if (strcmp(name,"StressTensorxy")==0) return StressTensorxyEnum; - else if (strcmp(name,"StressTensorxz")==0) return StressTensorxzEnum; - else if (strcmp(name,"StressTensoryy")==0) return StressTensoryyEnum; - else if (strcmp(name,"StressTensoryz")==0) return StressTensoryzEnum; - else if (strcmp(name,"StressTensorzz")==0) return StressTensorzzEnum; - else if (strcmp(name,"SurfaceAbsMisfit")==0) return SurfaceAbsMisfitEnum; - else if (strcmp(name,"SurfaceAbsVelMisfit")==0) return SurfaceAbsVelMisfitEnum; - else if (strcmp(name,"SurfaceArea")==0) return SurfaceAreaEnum; - else if (strcmp(name,"SurfaceAverageVelMisfit")==0) return SurfaceAverageVelMisfitEnum; - else if (strcmp(name,"SurfaceCrevasse")==0) return SurfaceCrevasseEnum; - else if (strcmp(name,"Surface")==0) return SurfaceEnum; - else if (strcmp(name,"SurfaceLogVelMisfit")==0) return SurfaceLogVelMisfitEnum; - else if (strcmp(name,"SurfaceLogVxVyMisfit")==0) return SurfaceLogVxVyMisfitEnum; - else if (strcmp(name,"SurfaceObservation")==0) return SurfaceObservationEnum; - else if (strcmp(name,"SurfaceRelVelMisfit")==0) return SurfaceRelVelMisfitEnum; - else if (strcmp(name,"SurfaceSlopeX")==0) return SurfaceSlopeXEnum; - else if (strcmp(name,"SurfaceSlopeY")==0) return SurfaceSlopeYEnum; - else if (strcmp(name,"Temperature")==0) return TemperatureEnum; - else if (strcmp(name,"TemperaturePDD")==0) return TemperaturePDDEnum; - else if (strcmp(name,"TemperaturePicard")==0) return TemperaturePicardEnum; - else if (strcmp(name,"TemperatureSEMIC")==0) return TemperatureSEMICEnum; - else if (strcmp(name,"ThermalSpctemperature")==0) return ThermalSpctemperatureEnum; - else if (strcmp(name,"ThicknessAbsGradient")==0) return ThicknessAbsGradientEnum; - else if (strcmp(name,"ThicknessAbsMisfit")==0) return ThicknessAbsMisfitEnum; - else if (strcmp(name,"ThicknessAcrossGradient")==0) return ThicknessAcrossGradientEnum; - else if (strcmp(name,"ThicknessAlongGradient")==0) return ThicknessAlongGradientEnum; - else if (strcmp(name,"Thickness")==0) return ThicknessEnum; - else if (strcmp(name,"ThicknessPositive")==0) return ThicknessPositiveEnum; - else if (strcmp(name,"Vel")==0) return VelEnum; - else if (strcmp(name,"VxAverage")==0) return VxAverageEnum; - else if (strcmp(name,"Vx")==0) return VxEnum; - else if (strcmp(name,"VxMesh")==0) return VxMeshEnum; - else if (strcmp(name,"VxObs")==0) return VxObsEnum; - else if (strcmp(name,"VyAverage")==0) return VyAverageEnum; - else if (strcmp(name,"Vy")==0) return VyEnum; - else if (strcmp(name,"VyMesh")==0) return VyMeshEnum; - else if (strcmp(name,"VyObs")==0) return VyObsEnum; - else if (strcmp(name,"Vz")==0) return VzEnum; - else if (strcmp(name,"VzFS")==0) return VzFSEnum; - else if (strcmp(name,"VzHO")==0) return VzHOEnum; - else if (strcmp(name,"VzMesh")==0) return VzMeshEnum; - else if (strcmp(name,"VzSSA")==0) return VzSSAEnum; - else if (strcmp(name,"WaterColumnOld")==0) return WaterColumnOldEnum; - else if (strcmp(name,"Watercolumn")==0) return WatercolumnEnum; - else if (strcmp(name,"WaterfractionDrainage")==0) return WaterfractionDrainageEnum; - else if (strcmp(name,"WaterfractionDrainageIntegrated")==0) return WaterfractionDrainageIntegratedEnum; - else if (strcmp(name,"Waterfraction")==0) return WaterfractionEnum; - else if (strcmp(name,"Waterheight")==0) return WaterheightEnum; - else if (strcmp(name,"WeightsSurfaceObservation")==0) return WeightsSurfaceObservationEnum; - else if (strcmp(name,"Outputdefinition1")==0) return Outputdefinition1Enum; - else if (strcmp(name,"Outputdefinition10")==0) return Outputdefinition10Enum; - else if (strcmp(name,"Outputdefinition11")==0) return Outputdefinition11Enum; - else if (strcmp(name,"Outputdefinition12")==0) return Outputdefinition12Enum; - else if (strcmp(name,"Outputdefinition13")==0) return Outputdefinition13Enum; - else if (strcmp(name,"Outputdefinition14")==0) return Outputdefinition14Enum; - else if (strcmp(name,"Outputdefinition15")==0) return Outputdefinition15Enum; - else if (strcmp(name,"Outputdefinition16")==0) return Outputdefinition16Enum; - else if (strcmp(name,"Outputdefinition17")==0) return Outputdefinition17Enum; - else if (strcmp(name,"Outputdefinition18")==0) return Outputdefinition18Enum; - else if (strcmp(name,"Outputdefinition19")==0) return Outputdefinition19Enum; - else if (strcmp(name,"Outputdefinition20")==0) return Outputdefinition20Enum; - else if (strcmp(name,"Outputdefinition21")==0) return Outputdefinition21Enum; - else if (strcmp(name,"Outputdefinition22")==0) return Outputdefinition22Enum; - else if (strcmp(name,"Outputdefinition23")==0) return Outputdefinition23Enum; - else if (strcmp(name,"Outputdefinition24")==0) return Outputdefinition24Enum; - else if (strcmp(name,"Outputdefinition25")==0) return Outputdefinition25Enum; - else if (strcmp(name,"Outputdefinition26")==0) return Outputdefinition26Enum; - else if (strcmp(name,"Outputdefinition27")==0) return Outputdefinition27Enum; - else if (strcmp(name,"Outputdefinition28")==0) return Outputdefinition28Enum; - else if (strcmp(name,"Outputdefinition29")==0) return Outputdefinition29Enum; - else if (strcmp(name,"Outputdefinition2")==0) return Outputdefinition2Enum; - else if (strcmp(name,"Outputdefinition30")==0) return Outputdefinition30Enum; - else if (strcmp(name,"Outputdefinition31")==0) return Outputdefinition31Enum; - else if (strcmp(name,"Outputdefinition32")==0) return Outputdefinition32Enum; - else if (strcmp(name,"Outputdefinition33")==0) return Outputdefinition33Enum; - else if (strcmp(name,"Outputdefinition34")==0) return Outputdefinition34Enum; - else if (strcmp(name,"Outputdefinition35")==0) return Outputdefinition35Enum; - else if (strcmp(name,"Outputdefinition36")==0) return Outputdefinition36Enum; - else if (strcmp(name,"Outputdefinition37")==0) return Outputdefinition37Enum; - else if (strcmp(name,"Outputdefinition38")==0) return Outputdefinition38Enum; - else if (strcmp(name,"Outputdefinition39")==0) return Outputdefinition39Enum; - else if (strcmp(name,"Outputdefinition3")==0) return Outputdefinition3Enum; - else if (strcmp(name,"Outputdefinition40")==0) return Outputdefinition40Enum; - else if (strcmp(name,"Outputdefinition41")==0) return Outputdefinition41Enum; - else if (strcmp(name,"Outputdefinition42")==0) return Outputdefinition42Enum; - else if (strcmp(name,"Outputdefinition43")==0) return Outputdefinition43Enum; - else if (strcmp(name,"Outputdefinition44")==0) return Outputdefinition44Enum; - else if (strcmp(name,"Outputdefinition45")==0) return Outputdefinition45Enum; - else if (strcmp(name,"Outputdefinition46")==0) return Outputdefinition46Enum; - else if (strcmp(name,"Outputdefinition47")==0) return Outputdefinition47Enum; - else if (strcmp(name,"Outputdefinition48")==0) return Outputdefinition48Enum; - else if (strcmp(name,"Outputdefinition49")==0) return Outputdefinition49Enum; - else if (strcmp(name,"Outputdefinition4")==0) return Outputdefinition4Enum; - else if (strcmp(name,"Outputdefinition50")==0) return Outputdefinition50Enum; - else if (strcmp(name,"Outputdefinition51")==0) return Outputdefinition51Enum; - else if (strcmp(name,"Outputdefinition52")==0) return Outputdefinition52Enum; - else if (strcmp(name,"Outputdefinition53")==0) return Outputdefinition53Enum; - else if (strcmp(name,"Outputdefinition54")==0) return Outputdefinition54Enum; - else if (strcmp(name,"Outputdefinition55")==0) return Outputdefinition55Enum; - else if (strcmp(name,"Outputdefinition56")==0) return Outputdefinition56Enum; - else if (strcmp(name,"Outputdefinition57")==0) return Outputdefinition57Enum; - else if (strcmp(name,"Outputdefinition58")==0) return Outputdefinition58Enum; - else if (strcmp(name,"Outputdefinition59")==0) return Outputdefinition59Enum; - else if (strcmp(name,"Outputdefinition5")==0) return Outputdefinition5Enum; - else if (strcmp(name,"Outputdefinition60")==0) return Outputdefinition60Enum; - else if (strcmp(name,"Outputdefinition61")==0) return Outputdefinition61Enum; - else if (strcmp(name,"Outputdefinition62")==0) return Outputdefinition62Enum; - else if (strcmp(name,"Outputdefinition63")==0) return Outputdefinition63Enum; - else if (strcmp(name,"Outputdefinition64")==0) return Outputdefinition64Enum; - else if (strcmp(name,"Outputdefinition65")==0) return Outputdefinition65Enum; - else if (strcmp(name,"Outputdefinition66")==0) return Outputdefinition66Enum; - else if (strcmp(name,"Outputdefinition67")==0) return Outputdefinition67Enum; - else stage=8; - } - if(stage==8){ - if (strcmp(name,"Outputdefinition68")==0) return Outputdefinition68Enum; - else if (strcmp(name,"Outputdefinition69")==0) return Outputdefinition69Enum; - else if (strcmp(name,"Outputdefinition6")==0) return Outputdefinition6Enum; - else if (strcmp(name,"Outputdefinition70")==0) return Outputdefinition70Enum; - else if (strcmp(name,"Outputdefinition71")==0) return Outputdefinition71Enum; - else if (strcmp(name,"Outputdefinition72")==0) return Outputdefinition72Enum; - else if (strcmp(name,"Outputdefinition73")==0) return Outputdefinition73Enum; - else if (strcmp(name,"Outputdefinition74")==0) return Outputdefinition74Enum; - else if (strcmp(name,"Outputdefinition75")==0) return Outputdefinition75Enum; - else if (strcmp(name,"Outputdefinition76")==0) return Outputdefinition76Enum; - else if (strcmp(name,"Outputdefinition77")==0) return Outputdefinition77Enum; - else if (strcmp(name,"Outputdefinition78")==0) return Outputdefinition78Enum; - else if (strcmp(name,"Outputdefinition79")==0) return Outputdefinition79Enum; - else if (strcmp(name,"Outputdefinition7")==0) return Outputdefinition7Enum; - else if (strcmp(name,"Outputdefinition80")==0) return Outputdefinition80Enum; - else if (strcmp(name,"Outputdefinition81")==0) return Outputdefinition81Enum; - else if (strcmp(name,"Outputdefinition82")==0) return Outputdefinition82Enum; - else if (strcmp(name,"Outputdefinition83")==0) return Outputdefinition83Enum; - else if (strcmp(name,"Outputdefinition84")==0) return Outputdefinition84Enum; - else if (strcmp(name,"Outputdefinition85")==0) return Outputdefinition85Enum; - else if (strcmp(name,"Outputdefinition86")==0) return Outputdefinition86Enum; - else if (strcmp(name,"Outputdefinition87")==0) return Outputdefinition87Enum; - else if (strcmp(name,"Outputdefinition88")==0) return Outputdefinition88Enum; - else if (strcmp(name,"Outputdefinition89")==0) return Outputdefinition89Enum; - else if (strcmp(name,"Outputdefinition8")==0) return Outputdefinition8Enum; - else if (strcmp(name,"Outputdefinition90")==0) return Outputdefinition90Enum; - else if (strcmp(name,"Outputdefinition91")==0) return Outputdefinition91Enum; - else if (strcmp(name,"Outputdefinition92")==0) return Outputdefinition92Enum; - else if (strcmp(name,"Outputdefinition93")==0) return Outputdefinition93Enum; - else if (strcmp(name,"Outputdefinition94")==0) return Outputdefinition94Enum; - else if (strcmp(name,"Outputdefinition95")==0) return Outputdefinition95Enum; - else if (strcmp(name,"Outputdefinition96")==0) return Outputdefinition96Enum; - else if (strcmp(name,"Outputdefinition97")==0) return Outputdefinition97Enum; - else if (strcmp(name,"Outputdefinition98")==0) return Outputdefinition98Enum; - else if (strcmp(name,"Outputdefinition99")==0) return Outputdefinition99Enum; - else if (strcmp(name,"Outputdefinition9")==0) return Outputdefinition9Enum; - else if (strcmp(name,"Outputdefinition100")==0) return Outputdefinition100Enum; - else if (strcmp(name,"InputsEND")==0) return InputsENDEnum; - else if (strcmp(name,"Absolute")==0) return AbsoluteEnum; - else if (strcmp(name,"AdaptiveTimestepping")==0) return AdaptiveTimesteppingEnum; - else if (strcmp(name,"AdjointBalancethickness2Analysis")==0) return AdjointBalancethickness2AnalysisEnum; - else if (strcmp(name,"AdjointBalancethicknessAnalysis")==0) return AdjointBalancethicknessAnalysisEnum; - else if (strcmp(name,"AdjointHorizAnalysis")==0) return AdjointHorizAnalysisEnum; - else if (strcmp(name,"AggressiveMigration")==0) return AggressiveMigrationEnum; - else if (strcmp(name,"AmrBamg")==0) return AmrBamgEnum; - else if (strcmp(name,"AmrNeopz")==0) return AmrNeopzEnum; - else if (strcmp(name,"AndroidFrictionCoefficient")==0) return AndroidFrictionCoefficientEnum; - else if (strcmp(name,"Arrhenius")==0) return ArrheniusEnum; - else if (strcmp(name,"AutodiffJacobian")==0) return AutodiffJacobianEnum; - else if (strcmp(name,"Balancethickness2Analysis")==0) return Balancethickness2AnalysisEnum; - else if (strcmp(name,"Balancethickness2Solution")==0) return Balancethickness2SolutionEnum; - else if (strcmp(name,"BalancethicknessAnalysis")==0) return BalancethicknessAnalysisEnum; - else if (strcmp(name,"BalancethicknessApparentMassbalance")==0) return BalancethicknessApparentMassbalanceEnum; - else if (strcmp(name,"BalancethicknessSoftAnalysis")==0) return BalancethicknessSoftAnalysisEnum; - else if (strcmp(name,"BalancethicknessSoftSolution")==0) return BalancethicknessSoftSolutionEnum; - else if (strcmp(name,"BalancethicknessSolution")==0) return BalancethicknessSolutionEnum; - else if (strcmp(name,"BalancethicknessSpcthickness")==0) return BalancethicknessSpcthicknessEnum; - else if (strcmp(name,"BalancevelocityAnalysis")==0) return BalancevelocityAnalysisEnum; - else if (strcmp(name,"BalancevelocitySolution")==0) return BalancevelocitySolutionEnum; - else if (strcmp(name,"BasalforcingsIsmip6")==0) return BasalforcingsIsmip6Enum; - else if (strcmp(name,"BasalforcingsPico")==0) return BasalforcingsPicoEnum; - else if (strcmp(name,"BedSlopeSolution")==0) return BedSlopeSolutionEnum; - else if (strcmp(name,"BoolExternalResult")==0) return BoolExternalResultEnum; - else if (strcmp(name,"BoolInput")==0) return BoolInputEnum; - else if (strcmp(name,"BoolParam")==0) return BoolParamEnum; - else if (strcmp(name,"Boundary")==0) return BoundaryEnum; - else if (strcmp(name,"BuddJacka")==0) return BuddJackaEnum; - else if (strcmp(name,"CalvingDev2")==0) return CalvingDev2Enum; - else if (strcmp(name,"CalvingHab")==0) return CalvingHabEnum; - else if (strcmp(name,"CalvingLevermann")==0) return CalvingLevermannEnum; - else if (strcmp(name,"CalvingVonmises")==0) return CalvingVonmisesEnum; - else if (strcmp(name,"Cfdragcoeffabsgrad")==0) return CfdragcoeffabsgradEnum; - else if (strcmp(name,"Cfsurfacelogvel")==0) return CfsurfacelogvelEnum; - else if (strcmp(name,"Cfsurfacesquare")==0) return CfsurfacesquareEnum; - else if (strcmp(name,"Channel")==0) return ChannelEnum; - else if (strcmp(name,"ChannelArea")==0) return ChannelAreaEnum; - else if (strcmp(name,"Closed")==0) return ClosedEnum; - else if (strcmp(name,"Colinear")==0) return ColinearEnum; - else if (strcmp(name,"Constraints")==0) return ConstraintsEnum; - else if (strcmp(name,"Contact")==0) return ContactEnum; - else if (strcmp(name,"Contour")==0) return ContourEnum; - else if (strcmp(name,"Contours")==0) return ContoursEnum; - else if (strcmp(name,"ControlInput")==0) return ControlInputEnum; - else if (strcmp(name,"ControlInputGrad")==0) return ControlInputGradEnum; - else if (strcmp(name,"ControlInputMaxs")==0) return ControlInputMaxsEnum; - else if (strcmp(name,"ControlInputMins")==0) return ControlInputMinsEnum; - else if (strcmp(name,"ControlInputValues")==0) return ControlInputValuesEnum; - else if (strcmp(name,"CrouzeixRaviart")==0) return CrouzeixRaviartEnum; - else if (strcmp(name,"Cuffey")==0) return CuffeyEnum; - else if (strcmp(name,"CuffeyTemperate")==0) return CuffeyTemperateEnum; - else if (strcmp(name,"DamageEvolutionAnalysis")==0) return DamageEvolutionAnalysisEnum; - else if (strcmp(name,"DamageEvolutionSolution")==0) return DamageEvolutionSolutionEnum; - else if (strcmp(name,"DataSet")==0) return DataSetEnum; - else if (strcmp(name,"DataSetParam")==0) return DataSetParamEnum; - else if (strcmp(name,"DatasetInput")==0) return DatasetInputEnum; - else if (strcmp(name,"DefaultAnalysis")==0) return DefaultAnalysisEnum; - else if (strcmp(name,"DefaultCalving")==0) return DefaultCalvingEnum; - else if (strcmp(name,"Dense")==0) return DenseEnum; - else if (strcmp(name,"DependentObject")==0) return DependentObjectEnum; - else if (strcmp(name,"DepthAverageAnalysis")==0) return DepthAverageAnalysisEnum; - else if (strcmp(name,"DeviatoricStressErrorEstimator")==0) return DeviatoricStressErrorEstimatorEnum; - else if (strcmp(name,"Divergence")==0) return DivergenceEnum; - else if (strcmp(name,"Domain3Dsurface")==0) return Domain3DsurfaceEnum; - else if (strcmp(name,"DoubleArrayInput")==0) return DoubleArrayInputEnum; - else if (strcmp(name,"DoubleExternalResult")==0) return DoubleExternalResultEnum; - else if (strcmp(name,"DoubleInput")==0) return DoubleInputEnum; - else if (strcmp(name,"DoubleMatArrayParam")==0) return DoubleMatArrayParamEnum; - else if (strcmp(name,"DoubleMatExternalResult")==0) return DoubleMatExternalResultEnum; - else if (strcmp(name,"DoubleMatParam")==0) return DoubleMatParamEnum; - else if (strcmp(name,"DoubleParam")==0) return DoubleParamEnum; - else if (strcmp(name,"DoubleVecParam")==0) return DoubleVecParamEnum; - else if (strcmp(name,"Element")==0) return ElementEnum; - else if (strcmp(name,"ElementHook")==0) return ElementHookEnum; - else if (strcmp(name,"ElementSId")==0) return ElementSIdEnum; - else if (strcmp(name,"EnthalpyAnalysis")==0) return EnthalpyAnalysisEnum; - else if (strcmp(name,"EsaAnalysis")==0) return EsaAnalysisEnum; - else if (strcmp(name,"EsaSolution")==0) return EsaSolutionEnum; - else if (strcmp(name,"EsaTransitions")==0) return EsaTransitionsEnum; - else if (strcmp(name,"ExternalResult")==0) return ExternalResultEnum; - else if (strcmp(name,"ExtrapolationAnalysis")==0) return ExtrapolationAnalysisEnum; - else stage=9; - } - if(stage==9){ - if (strcmp(name,"ExtrudeFromBaseAnalysis")==0) return ExtrudeFromBaseAnalysisEnum; - else if (strcmp(name,"ExtrudeFromTopAnalysis")==0) return ExtrudeFromTopAnalysisEnum; - else if (strcmp(name,"FSApproximation")==0) return FSApproximationEnum; - else if (strcmp(name,"FSSolver")==0) return FSSolverEnum; - else if (strcmp(name,"FSpressure")==0) return FSpressureEnum; - else if (strcmp(name,"FSvelocity")==0) return FSvelocityEnum; - else if (strcmp(name,"FemModel")==0) return FemModelEnum; - else if (strcmp(name,"FileParam")==0) return FileParamEnum; - else if (strcmp(name,"FixedTimestepping")==0) return FixedTimesteppingEnum; - else if (strcmp(name,"FloatingArea")==0) return FloatingAreaEnum; - else if (strcmp(name,"FloatingAreaScaled")==0) return FloatingAreaScaledEnum; - else if (strcmp(name,"FloatingMeltRate")==0) return FloatingMeltRateEnum; - else if (strcmp(name,"Free")==0) return FreeEnum; - else if (strcmp(name,"FreeSurfaceBaseAnalysis")==0) return FreeSurfaceBaseAnalysisEnum; - else if (strcmp(name,"FreeSurfaceTopAnalysis")==0) return FreeSurfaceTopAnalysisEnum; - else if (strcmp(name,"FrontalForcingsDefault")==0) return FrontalForcingsDefaultEnum; - else if (strcmp(name,"FrontalForcingsRignot")==0) return FrontalForcingsRignotEnum; - else if (strcmp(name,"Fset")==0) return FsetEnum; - else if (strcmp(name,"FullMeltOnPartiallyFloating")==0) return FullMeltOnPartiallyFloatingEnum; - else if (strcmp(name,"GLheightadvectionAnalysis")==0) return GLheightadvectionAnalysisEnum; - else if (strcmp(name,"GaussPenta")==0) return GaussPentaEnum; - else if (strcmp(name,"GaussSeg")==0) return GaussSegEnum; - else if (strcmp(name,"GaussTetra")==0) return GaussTetraEnum; - else if (strcmp(name,"GaussTria")==0) return GaussTriaEnum; - else if (strcmp(name,"GenericOption")==0) return GenericOptionEnum; - else if (strcmp(name,"GenericParam")==0) return GenericParamEnum; - else if (strcmp(name,"GiaIvinsAnalysis")==0) return GiaIvinsAnalysisEnum; - else if (strcmp(name,"GiaSolution")==0) return GiaSolutionEnum; - else if (strcmp(name,"Gradient1")==0) return Gradient1Enum; - else if (strcmp(name,"Gradient2")==0) return Gradient2Enum; - else if (strcmp(name,"Gradient3")==0) return Gradient3Enum; - else if (strcmp(name,"GroundedArea")==0) return GroundedAreaEnum; - else if (strcmp(name,"GroundedAreaScaled")==0) return GroundedAreaScaledEnum; - else if (strcmp(name,"GroundingOnly")==0) return GroundingOnlyEnum; - else if (strcmp(name,"GroundinglineMassFlux")==0) return GroundinglineMassFluxEnum; - else if (strcmp(name,"Gset")==0) return GsetEnum; - else if (strcmp(name,"Gsl")==0) return GslEnum; - else if (strcmp(name,"HOApproximation")==0) return HOApproximationEnum; - else if (strcmp(name,"HOFSApproximation")==0) return HOFSApproximationEnum; - else if (strcmp(name,"Hook")==0) return HookEnum; - else if (strcmp(name,"HydrologyDCEfficientAnalysis")==0) return HydrologyDCEfficientAnalysisEnum; - else if (strcmp(name,"HydrologyDCInefficientAnalysis")==0) return HydrologyDCInefficientAnalysisEnum; - else if (strcmp(name,"HydrologyGlaDSAnalysis")==0) return HydrologyGlaDSAnalysisEnum; - else if (strcmp(name,"HydrologyGlaDS")==0) return HydrologyGlaDSEnum; - else if (strcmp(name,"HydrologyPismAnalysis")==0) return HydrologyPismAnalysisEnum; - else if (strcmp(name,"HydrologyShaktiAnalysis")==0) return HydrologyShaktiAnalysisEnum; - else if (strcmp(name,"HydrologyShreveAnalysis")==0) return HydrologyShreveAnalysisEnum; - else if (strcmp(name,"HydrologySolution")==0) return HydrologySolutionEnum; - else if (strcmp(name,"Hydrologydc")==0) return HydrologydcEnum; - else if (strcmp(name,"Hydrologypism")==0) return HydrologypismEnum; - else if (strcmp(name,"Hydrologyshakti")==0) return HydrologyshaktiEnum; - else if (strcmp(name,"Hydrologyshreve")==0) return HydrologyshreveEnum; - else if (strcmp(name,"IceMass")==0) return IceMassEnum; - else if (strcmp(name,"IceMassScaled")==0) return IceMassScaledEnum; - else if (strcmp(name,"IceVolumeAboveFloatation")==0) return IceVolumeAboveFloatationEnum; - else if (strcmp(name,"IceVolumeAboveFloatationScaled")==0) return IceVolumeAboveFloatationScaledEnum; - else if (strcmp(name,"IceVolume")==0) return IceVolumeEnum; - else if (strcmp(name,"IceVolumeScaled")==0) return IceVolumeScaledEnum; - else if (strcmp(name,"IcefrontMassFlux")==0) return IcefrontMassFluxEnum; - else if (strcmp(name,"IcefrontMassFluxLevelset")==0) return IcefrontMassFluxLevelsetEnum; - else if (strcmp(name,"Incremental")==0) return IncrementalEnum; - else if (strcmp(name,"Indexed")==0) return IndexedEnum; - else if (strcmp(name,"IntExternalResult")==0) return IntExternalResultEnum; - else if (strcmp(name,"IntInput")==0) return IntInputEnum; - else if (strcmp(name,"IntMatExternalResult")==0) return IntMatExternalResultEnum; - else if (strcmp(name,"IntMatParam")==0) return IntMatParamEnum; - else if (strcmp(name,"IntParam")==0) return IntParamEnum; - else if (strcmp(name,"IntVecParam")==0) return IntVecParamEnum; - else if (strcmp(name,"Internal")==0) return InternalEnum; - else if (strcmp(name,"Intersect")==0) return IntersectEnum; - else if (strcmp(name,"InversionVzObs")==0) return InversionVzObsEnum; - else if (strcmp(name,"J")==0) return JEnum; - else if (strcmp(name,"L1L2Approximation")==0) return L1L2ApproximationEnum; - else if (strcmp(name,"L2ProjectionBaseAnalysis")==0) return L2ProjectionBaseAnalysisEnum; - else if (strcmp(name,"L2ProjectionEPLAnalysis")==0) return L2ProjectionEPLAnalysisEnum; - else if (strcmp(name,"LACrouzeixRaviart")==0) return LACrouzeixRaviartEnum; - else if (strcmp(name,"LATaylorHood")==0) return LATaylorHoodEnum; - else if (strcmp(name,"LambdaS")==0) return LambdaSEnum; - else if (strcmp(name,"LevelsetAnalysis")==0) return LevelsetAnalysisEnum; - else if (strcmp(name,"LevelsetfunctionPicard")==0) return LevelsetfunctionPicardEnum; - else if (strcmp(name,"LinearFloatingMeltRate")==0) return LinearFloatingMeltRateEnum; - else if (strcmp(name,"LliboutryDuval")==0) return LliboutryDuvalEnum; - else if (strcmp(name,"Loads")==0) return LoadsEnum; - else if (strcmp(name,"LoveAnalysis")==0) return LoveAnalysisEnum; - else if (strcmp(name,"LoveHi")==0) return LoveHiEnum; - else if (strcmp(name,"LoveHr")==0) return LoveHrEnum; - else if (strcmp(name,"LoveKernelsImag")==0) return LoveKernelsImagEnum; - else if (strcmp(name,"LoveKernelsReal")==0) return LoveKernelsRealEnum; - else if (strcmp(name,"LoveKi")==0) return LoveKiEnum; - else if (strcmp(name,"LoveKr")==0) return LoveKrEnum; - else if (strcmp(name,"LoveLi")==0) return LoveLiEnum; - else if (strcmp(name,"LoveLr")==0) return LoveLrEnum; - else if (strcmp(name,"LoveSolution")==0) return LoveSolutionEnum; - else if (strcmp(name,"MINI")==0) return MINIEnum; - else if (strcmp(name,"MINIcondensed")==0) return MINIcondensedEnum; - else if (strcmp(name,"MantlePlumeGeothermalFlux")==0) return MantlePlumeGeothermalFluxEnum; - else if (strcmp(name,"MassFlux")==0) return MassFluxEnum; - else if (strcmp(name,"Masscon")==0) return MassconEnum; - else if (strcmp(name,"Massconaxpby")==0) return MassconaxpbyEnum; - else if (strcmp(name,"Massfluxatgate")==0) return MassfluxatgateEnum; - else if (strcmp(name,"MasstransportAnalysis")==0) return MasstransportAnalysisEnum; - else if (strcmp(name,"MasstransportSolution")==0) return MasstransportSolutionEnum; - else if (strcmp(name,"Matdamageice")==0) return MatdamageiceEnum; - else if (strcmp(name,"Matenhancedice")==0) return MatenhancediceEnum; - else if (strcmp(name,"Materials")==0) return MaterialsEnum; - else if (strcmp(name,"Matestar")==0) return MatestarEnum; - else if (strcmp(name,"Matice")==0) return MaticeEnum; - else if (strcmp(name,"Matlitho")==0) return MatlithoEnum; - else if (strcmp(name,"MatrixParam")==0) return MatrixParamEnum; - else if (strcmp(name,"MaxAbsVx")==0) return MaxAbsVxEnum; - else if (strcmp(name,"MaxAbsVy")==0) return MaxAbsVyEnum; - else if (strcmp(name,"MaxAbsVz")==0) return MaxAbsVzEnum; - else if (strcmp(name,"MaxDivergence")==0) return MaxDivergenceEnum; - else if (strcmp(name,"MaxVel")==0) return MaxVelEnum; - else if (strcmp(name,"MaxVx")==0) return MaxVxEnum; - else if (strcmp(name,"MaxVy")==0) return MaxVyEnum; - else if (strcmp(name,"MaxVz")==0) return MaxVzEnum; - else if (strcmp(name,"Melange")==0) return MelangeEnum; - else if (strcmp(name,"MeltingAnalysis")==0) return MeltingAnalysisEnum; - else if (strcmp(name,"MeshElements")==0) return MeshElementsEnum; - else stage=10; - } - if(stage==10){ - if (strcmp(name,"MeshX")==0) return MeshXEnum; - else if (strcmp(name,"MeshY")==0) return MeshYEnum; - else if (strcmp(name,"MinVel")==0) return MinVelEnum; - else if (strcmp(name,"MinVx")==0) return MinVxEnum; - else if (strcmp(name,"MinVy")==0) return MinVyEnum; - else if (strcmp(name,"MinVz")==0) return MinVzEnum; - else if (strcmp(name,"MismipFloatingMeltRate")==0) return MismipFloatingMeltRateEnum; - else if (strcmp(name,"Moulin")==0) return MoulinEnum; - else if (strcmp(name,"MpiDense")==0) return MpiDenseEnum; - else if (strcmp(name,"Mpi")==0) return MpiEnum; - else if (strcmp(name,"MpiSparse")==0) return MpiSparseEnum; - else if (strcmp(name,"Mumps")==0) return MumpsEnum; - else if (strcmp(name,"NoFrictionOnPartiallyFloating")==0) return NoFrictionOnPartiallyFloatingEnum; - else if (strcmp(name,"NoMeltOnPartiallyFloating")==0) return NoMeltOnPartiallyFloatingEnum; - else if (strcmp(name,"Nodal")==0) return NodalEnum; - else if (strcmp(name,"Nodalvalue")==0) return NodalvalueEnum; - else if (strcmp(name,"NodeSId")==0) return NodeSIdEnum; - else if (strcmp(name,"NoneApproximation")==0) return NoneApproximationEnum; - else if (strcmp(name,"None")==0) return NoneEnum; - else if (strcmp(name,"Numberedcostfunction")==0) return NumberedcostfunctionEnum; - else if (strcmp(name,"Numericalflux")==0) return NumericalfluxEnum; - else if (strcmp(name,"OldGradient")==0) return OldGradientEnum; - else if (strcmp(name,"OneLayerP4z")==0) return OneLayerP4zEnum; - else if (strcmp(name,"Open")==0) return OpenEnum; - else if (strcmp(name,"Option")==0) return OptionEnum; - else if (strcmp(name,"P0Array")==0) return P0ArrayEnum; - else if (strcmp(name,"P1DG")==0) return P1DGEnum; - else if (strcmp(name,"P1P1")==0) return P1P1Enum; - else if (strcmp(name,"P1P1GLS")==0) return P1P1GLSEnum; - else if (strcmp(name,"P1bubble")==0) return P1bubbleEnum; - else if (strcmp(name,"P1bubblecondensed")==0) return P1bubblecondensedEnum; - else if (strcmp(name,"P1xP2")==0) return P1xP2Enum; - else if (strcmp(name,"P1xP3")==0) return P1xP3Enum; - else if (strcmp(name,"P1xP4")==0) return P1xP4Enum; - else if (strcmp(name,"P2")==0) return P2Enum; - else if (strcmp(name,"P2bubble")==0) return P2bubbleEnum; - else if (strcmp(name,"P2bubblecondensed")==0) return P2bubblecondensedEnum; - else if (strcmp(name,"P2xP1")==0) return P2xP1Enum; - else if (strcmp(name,"P2xP4")==0) return P2xP4Enum; - else if (strcmp(name,"Paterson")==0) return PatersonEnum; - else if (strcmp(name,"Pengrid")==0) return PengridEnum; - else if (strcmp(name,"Penpair")==0) return PenpairEnum; - else if (strcmp(name,"Penta")==0) return PentaEnum; - else if (strcmp(name,"PentaInput")==0) return PentaInputEnum; - else if (strcmp(name,"Profiler")==0) return ProfilerEnum; - else if (strcmp(name,"ProfilingCurrentFlops")==0) return ProfilingCurrentFlopsEnum; - else if (strcmp(name,"ProfilingCurrentMem")==0) return ProfilingCurrentMemEnum; - else if (strcmp(name,"ProfilingSolutionTime")==0) return ProfilingSolutionTimeEnum; - else if (strcmp(name,"Regionaloutput")==0) return RegionaloutputEnum; - else if (strcmp(name,"Regular")==0) return RegularEnum; - else if (strcmp(name,"Riftfront")==0) return RiftfrontEnum; - else if (strcmp(name,"SIAApproximation")==0) return SIAApproximationEnum; - else if (strcmp(name,"SMBcomponents")==0) return SMBcomponentsEnum; - else if (strcmp(name,"SMBd18opdd")==0) return SMBd18opddEnum; - else if (strcmp(name,"SMBforcing")==0) return SMBforcingEnum; - else if (strcmp(name,"SMBgcm")==0) return SMBgcmEnum; - else if (strcmp(name,"SMBgemb")==0) return SMBgembEnum; - else if (strcmp(name,"SMBgradients")==0) return SMBgradientsEnum; - else if (strcmp(name,"SMBgradientscomponents")==0) return SMBgradientscomponentsEnum; - else if (strcmp(name,"SMBgradientsela")==0) return SMBgradientselaEnum; - else if (strcmp(name,"SMBhenning")==0) return SMBhenningEnum; - else if (strcmp(name,"SMBmeltcomponents")==0) return SMBmeltcomponentsEnum; - else if (strcmp(name,"SMBpdd")==0) return SMBpddEnum; - else if (strcmp(name,"SMBpddSicopolis")==0) return SMBpddSicopolisEnum; - else if (strcmp(name,"SMBsemic")==0) return SMBsemicEnum; - else if (strcmp(name,"SSAApproximation")==0) return SSAApproximationEnum; - else if (strcmp(name,"SSAFSApproximation")==0) return SSAFSApproximationEnum; - else if (strcmp(name,"SSAHOApproximation")==0) return SSAHOApproximationEnum; - else if (strcmp(name,"Scaled")==0) return ScaledEnum; - else if (strcmp(name,"SealevelAbsolute")==0) return SealevelAbsoluteEnum; - else if (strcmp(name,"SealevelEmotion")==0) return SealevelEmotionEnum; - else if (strcmp(name,"SealevelInertiaTensorXZ")==0) return SealevelInertiaTensorXZEnum; - else if (strcmp(name,"SealevelInertiaTensorYZ")==0) return SealevelInertiaTensorYZEnum; - else if (strcmp(name,"SealevelInertiaTensorZZ")==0) return SealevelInertiaTensorZZEnum; - else if (strcmp(name,"SealevelNmotion")==0) return SealevelNmotionEnum; - else if (strcmp(name,"SealevelUmotion")==0) return SealevelUmotionEnum; - else if (strcmp(name,"SealevelriseAnalysis")==0) return SealevelriseAnalysisEnum; - else if (strcmp(name,"SealevelriseSolution")==0) return SealevelriseSolutionEnum; - else if (strcmp(name,"Seg")==0) return SegEnum; - else if (strcmp(name,"SegInput")==0) return SegInputEnum; - else if (strcmp(name,"Segment")==0) return SegmentEnum; - else if (strcmp(name,"SegmentRiftfront")==0) return SegmentRiftfrontEnum; - else if (strcmp(name,"Separate")==0) return SeparateEnum; - else if (strcmp(name,"Seq")==0) return SeqEnum; - else if (strcmp(name,"SmbAnalysis")==0) return SmbAnalysisEnum; - else if (strcmp(name,"SmbSolution")==0) return SmbSolutionEnum; - else if (strcmp(name,"SmoothAnalysis")==0) return SmoothAnalysisEnum; - else if (strcmp(name,"SoftMigration")==0) return SoftMigrationEnum; - else if (strcmp(name,"SpatialLinearFloatingMeltRate")==0) return SpatialLinearFloatingMeltRateEnum; - else if (strcmp(name,"SpcDynamic")==0) return SpcDynamicEnum; - else if (strcmp(name,"SpcStatic")==0) return SpcStaticEnum; - else if (strcmp(name,"SpcTransient")==0) return SpcTransientEnum; - else if (strcmp(name,"Sset")==0) return SsetEnum; - else if (strcmp(name,"SteadystateSolution")==0) return SteadystateSolutionEnum; - else if (strcmp(name,"StressIntensityFactor")==0) return StressIntensityFactorEnum; - else if (strcmp(name,"StressbalanceAnalysis")==0) return StressbalanceAnalysisEnum; - else if (strcmp(name,"StressbalanceConvergenceNumSteps")==0) return StressbalanceConvergenceNumStepsEnum; - else if (strcmp(name,"StressbalanceSIAAnalysis")==0) return StressbalanceSIAAnalysisEnum; - else if (strcmp(name,"StressbalanceSolution")==0) return StressbalanceSolutionEnum; - else if (strcmp(name,"StressbalanceVerticalAnalysis")==0) return StressbalanceVerticalAnalysisEnum; - else if (strcmp(name,"StringArrayParam")==0) return StringArrayParamEnum; - else if (strcmp(name,"StringExternalResult")==0) return StringExternalResultEnum; - else if (strcmp(name,"StringParam")==0) return StringParamEnum; - else if (strcmp(name,"SubelementFriction1")==0) return SubelementFriction1Enum; - else if (strcmp(name,"SubelementFriction2")==0) return SubelementFriction2Enum; - else if (strcmp(name,"SubelementMelt1")==0) return SubelementMelt1Enum; - else if (strcmp(name,"SubelementMelt2")==0) return SubelementMelt2Enum; - else if (strcmp(name,"SubelementMigration")==0) return SubelementMigrationEnum; - else if (strcmp(name,"SurfaceSlopeSolution")==0) return SurfaceSlopeSolutionEnum; - else if (strcmp(name,"TaylorHood")==0) return TaylorHoodEnum; - else if (strcmp(name,"Tetra")==0) return TetraEnum; - else if (strcmp(name,"TetraInput")==0) return TetraInputEnum; - else if (strcmp(name,"ThermalAnalysis")==0) return ThermalAnalysisEnum; - else if (strcmp(name,"ThermalSolution")==0) return ThermalSolutionEnum; - else if (strcmp(name,"ThicknessErrorEstimator")==0) return ThicknessErrorEstimatorEnum; - else if (strcmp(name,"TotalCalvingFlux")==0) return TotalCalvingFluxEnum; - else if (strcmp(name,"TotalCalvingFluxLevelset")==0) return TotalCalvingFluxLevelsetEnum; - else if (strcmp(name,"TotalFloatingBmb")==0) return TotalFloatingBmbEnum; - else if (strcmp(name,"TotalFloatingBmbScaled")==0) return TotalFloatingBmbScaledEnum; - else if (strcmp(name,"TotalGroundedBmb")==0) return TotalGroundedBmbEnum; - else stage=11; - } - if(stage==11){ - if (strcmp(name,"TotalGroundedBmbScaled")==0) return TotalGroundedBmbScaledEnum; - else if (strcmp(name,"TotalSmb")==0) return TotalSmbEnum; - else if (strcmp(name,"TotalSmbScaled")==0) return TotalSmbScaledEnum; - else if (strcmp(name,"TransientArrayParam")==0) return TransientArrayParamEnum; - else if (strcmp(name,"TransientInput")==0) return TransientInputEnum; - else if (strcmp(name,"TransientParam")==0) return TransientParamEnum; - else if (strcmp(name,"TransientSolution")==0) return TransientSolutionEnum; - else if (strcmp(name,"Tria")==0) return TriaEnum; - else if (strcmp(name,"TriaInput")==0) return TriaInputEnum; - else if (strcmp(name,"UzawaPressureAnalysis")==0) return UzawaPressureAnalysisEnum; - else if (strcmp(name,"VectorParam")==0) return VectorParamEnum; - else if (strcmp(name,"Vertex")==0) return VertexEnum; - else if (strcmp(name,"VertexLId")==0) return VertexLIdEnum; - else if (strcmp(name,"VertexPId")==0) return VertexPIdEnum; - else if (strcmp(name,"VertexSId")==0) return VertexSIdEnum; - else if (strcmp(name,"Vertices")==0) return VerticesEnum; - else if (strcmp(name,"ViscousHeating")==0) return ViscousHeatingEnum; - else if (strcmp(name,"Water")==0) return WaterEnum; - else if (strcmp(name,"XTaylorHood")==0) return XTaylorHoodEnum; - else if (strcmp(name,"XY")==0) return XYEnum; - else if (strcmp(name,"XYZ")==0) return XYZEnum; - else if (strcmp(name,"BalancethicknessD0")==0) return BalancethicknessD0Enum; - else if (strcmp(name,"BalancethicknessDiffusionCoefficient")==0) return BalancethicknessDiffusionCoefficientEnum; - else if (strcmp(name,"BilinearInterp")==0) return BilinearInterpEnum; - else if (strcmp(name,"CalvingdevCoeff")==0) return CalvingdevCoeffEnum; - else if (strcmp(name,"DeviatoricStress")==0) return DeviatoricStressEnum; - else if (strcmp(name,"EtaAbsGradient")==0) return EtaAbsGradientEnum; - else if (strcmp(name,"MeshZ")==0) return MeshZEnum; - else if (strcmp(name,"NearestInterp")==0) return NearestInterpEnum; - else if (strcmp(name,"OutputdefinitionList")==0) return OutputdefinitionListEnum; - else if (strcmp(name,"SealevelObs")==0) return SealevelObsEnum; - else if (strcmp(name,"SealevelWeights")==0) return SealevelWeightsEnum; - else if (strcmp(name,"StrainRate")==0) return StrainRateEnum; - else if (strcmp(name,"StressTensor")==0) return StressTensorEnum; - else if (strcmp(name,"StressbalanceViscosityOvershoot")==0) return StressbalanceViscosityOvershootEnum; - else if (strcmp(name,"SubelementMigration4")==0) return SubelementMigration4Enum; - else if (strcmp(name,"TimesteppingTimeAdapt")==0) return TimesteppingTimeAdaptEnum; - else if (strcmp(name,"TriangleInterp")==0) return TriangleInterpEnum; - else if (strcmp(name,"MaximumNumberOfDefinitions")==0) return MaximumNumberOfDefinitionsEnum; - else stage=12; } /*If we reach this point, the string provided has not been found*/