Index: /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp (revision 23993) +++ /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp (revision 23994) @@ -17,4 +17,1242 @@ 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 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 23993) +++ /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp (revision 23994) @@ -17,5 +17,1273 @@ 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,"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 if (strcmp(name,"TotalGroundedBmbScaled")==0) return TotalGroundedBmbScaledEnum; + else stage=11; + } + if(stage==11){ + 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*/