Index: ../trunk-jpl/src/c/shared/Enum/EnumDefinitions.h
===================================================================
--- ../trunk-jpl/src/c/shared/Enum/EnumDefinitions.h	(revision 22595)
+++ ../trunk-jpl/src/c/shared/Enum/EnumDefinitions.h	(revision 22596)
@@ -7,657 +7,1012 @@
 #define _ENUM_DEFINITIONS_
 
 enum definitions{
-	FemModelEnum,
 	ParametersSTARTEnum,
-	/*Parameters {{{*/
+	/*Parameters{{{*/
 	AdolcParamEnum,
-	FSSolverEnum,
-	FemModelCommEnum,
-	WorldCommEnum,
-	IcecapToEarthCommEnum,
-	ToMITgcmCommEnum,
-	NumModelsEnum,
-	ModelIdEnum,
-	EarthIdEnum,
-	SolutionTypeEnum,
+	AmrDeviatoricErrorGroupThresholdEnum,
+	AmrDeviatoricErrorMaximumEnum,
+	AmrDeviatoricErrorResolutionEnum,
+	AmrDeviatoricErrorThresholdEnum,
+	AmrErrEnum,
+	AmrFieldEnum,
+	AmrGradationEnum,
+	AmrGroundingLineDistanceEnum,
+	AmrGroundingLineResolutionEnum,
+	AmrHmaxEnum,
+	AmrHminEnum,
+	AmrIceFrontDistanceEnum,
+	AmrIceFrontResolutionEnum,
+	AmrKeepMetricEnum,
+	AmrLagEnum,
+	AmrLevelMaxEnum,
+	AmrRestartEnum,
+	AmrThicknessErrorGroupThresholdEnum,
+	AmrThicknessErrorMaximumEnum,
+	AmrThicknessErrorResolutionEnum,
+	AmrThicknessErrorThresholdEnum,
+	AmrTypeEnum,
+	AnalysisCounterEnum,
 	AnalysisTypeEnum,
-	AnalysisCounterEnum,
-	ConfigurationTypeEnum,
-	InputToExtrudeEnum,
-	InputToL2ProjectEnum,
-	InputToDepthaverageInEnum,
-	InputToDepthaverageOutEnum,
-	InputToSmoothEnum,
-	SmoothThicknessMultiplierEnum,
-	LevelsetStabilizationEnum,
-	TimesteppingTypeEnum,
-	FixedTimesteppingEnum,
-	AdaptiveTimesteppingEnum,
-	TimesteppingTimeStepMinEnum,
-	TimesteppingTimeStepMaxEnum,
-	/*}}}*/
-	InputsSTARTEnum,
-	/*Model fields {{{*/
-	AutodiffIsautodiffEnum, 
-	AutodiffNumDependentsEnum,
+	AugmentedLagrangianREnum,
+	AugmentedLagrangianRholambdaEnum,
+	AugmentedLagrangianRhopEnum,
+	AugmentedLagrangianRlambdaEnum,
+	AugmentedLagrangianThetaEnum,
+	AutodiffCbufsizeEnum,
 	AutodiffDependentObjectsEnum,
-	AutodiffNumIndependentsEnum,
-	AutodiffJacobianEnum,
-	AutodiffXpEnum,
 	AutodiffDriverEnum,
 	AutodiffFosForwardIndexEnum,
+	AutodiffFosReverseIndexEnum,
 	AutodiffFovForwardIndicesEnum,
-	AutodiffFosReverseIndexEnum,
-	AutodiffKeepEnum,
+	AutodiffGcTriggerMaxSizeEnum,
+	AutodiffGcTriggerRatioEnum,
+	AutodiffIsautodiffEnum,
+	AutodiffLbufsizeEnum,
+	AutodiffNumDependentsEnum,
+	AutodiffNumIndependentsEnum,
 	AutodiffObufsizeEnum,
-	AutodiffLbufsizeEnum,
-	AutodiffCbufsizeEnum,
 	AutodiffTbufsizeEnum,
-	AutodiffGcTriggerRatioEnum,
-	AutodiffGcTriggerMaxSizeEnum,
+	AutodiffXpEnum,
 	BalancethicknessStabilizationEnum,
-	BalancethicknessThickeningRateEnum,
+	BasalforcingsBottomplumedepthEnum,
+	BasalforcingsCrustthicknessEnum,
+	BasalforcingsDeepwaterElevationEnum,
+	BasalforcingsDeepwaterMeltingRateEnum,
+	BasalforcingsDtbgEnum,
 	BasalforcingsEnum,
-	BasalforcingsGeothermalfluxEnum,
-	BasalforcingsGroundediceMeltingRateEnum,
-	BasalforcingsFloatingiceMeltingRateEnum,
-	BasalforcingsDeepwaterMeltingRateEnum,
-	BasalforcingsDeepwaterElevationEnum,
-	BasalforcingsUpperwaterElevationEnum,
+	BasalforcingsLowercrustheatEnum,
+	BasalforcingsMantleconductivityEnum,
 	BasalforcingsMeltrateFactorEnum,
-	BasalforcingsThresholdThicknessEnum,
-	BasalforcingsUpperdepthMeltEnum,
-	BasalforcingsMantleconductivityEnum,
 	BasalforcingsNusseltEnum,
-	BasalforcingsDtbgEnum,
+	BasalforcingsPicoFarOceansalinityEnum,
+	BasalforcingsPicoGammaTEnum,
+	BasalforcingsPicoNumBasinsEnum,
+	BasalforcingsPicoOverturningCoeffEnum,
 	BasalforcingsPlumeradiusEnum,
-	BasalforcingsTopplumedepthEnum,
-	BasalforcingsBottomplumedepthEnum,
 	BasalforcingsPlumexEnum,
 	BasalforcingsPlumeyEnum,
-	BasalforcingsCrustthicknessEnum,
+	BasalforcingsThresholdThicknessEnum,
+	BasalforcingsTopplumedepthEnum,
+	BasalforcingsUppercrustheatEnum,
 	BasalforcingsUppercrustthicknessEnum,
-	BasalforcingsUppercrustheatEnum,
-	BasalforcingsLowercrustheatEnum,
-	FloatingMeltRateEnum,
-	LinearFloatingMeltRateEnum,
-	MismipFloatingMeltRateEnum,
-	MantlePlumeGeothermalFluxEnum,
-	BasalforcingsPicoEnum,
-	BasalforcingsPicoNumBasinsEnum,
-	BasalforcingsPicoBasinIdEnum,
-	BasalforcingsPicoMaxboxcountEnum,
-	BasalforcingsPicoBoxIdEnum,
-	BasalforcingsPicoOverturningCoeffEnum,
-	BasalforcingsPicoGammaTEnum,
-	BasalforcingsPicoFarOceantemperatureEnum,
-	BasalforcingsPicoFarOceansalinityEnum,
-	DistanceToGroundinglineEnum,
-	DistanceToCalvingfrontEnum,
-	BedEnum,
-	BaseEnum,
-	ConstantsGEnum,
-	ConstantsReferencetemperatureEnum,
+	BasalforcingsUpperdepthMeltEnum,
+	BasalforcingsUpperwaterElevationEnum,
+	CalvingCrevasseDepthEnum,
+	CalvingHeightAboveFloatationEnum,
+	CalvingLawEnum,
+	CalvingMaxEnum,
+	CalvingMinthicknessEnum,
+	ConfigurationTypeEnum,
 	ConstantsYtsEnum,
-	DependentObjectEnum,
-	StressbalanceAbstolEnum,
-	StressbalanceConvergenceNumStepsEnum,
-	StressbalanceIsnewtonEnum,
-	StressbalanceMaxiterEnum,
-	StressbalancePenaltyFactorEnum,
-	StressbalanceReltolEnum,
-	StressbalanceNumRequestedOutputsEnum,
-	StressbalanceRequestedOutputsEnum,
-	StressbalanceRestolEnum,
-	StressbalanceRiftPenaltyThresholdEnum,
-	StressbalanceShelfDampeningEnum,
-	StressbalanceFSreconditioningEnum,
-	StressbalanceViscosityOvershootEnum,
-	LoadingforceXEnum,
-	LoadingforceYEnum,
-	LoadingforceZEnum,
+	DamageC1Enum,
+	DamageC2Enum,
+	DamageC3Enum,
+	DamageEnum,
+	DamageEquivStressEnum,
+	DamageEvolutionNumRequestedOutputsEnum,
+	DamageEvolutionRequestedOutputsEnum,
+	DamageHealingEnum,
+	DamageKappaEnum,
+	DamageLawEnum,
+	DamageMaxDamageEnum,
+	DamageStabilizationEnum,
+	DamageStressThresholdEnum,
+	DebugProfilingEnum,
+	DomainDimensionEnum,
+	DomainTypeEnum,
+	EarthIdEnum,
+	EplZigZagCounterEnum,
+	EsaHElasticEnum,
+	EsaHemisphereEnum,
+	EsaRequestedOutputsEnum,
+	EsaUElasticEnum,
+	ExtrapolationVariableEnum,
+	FlowequationFeFSEnum,
+	FlowequationIsFSEnum,
+	FlowequationIsHOEnum,
+	FlowequationIsL1L2Enum,
 	FlowequationIsSIAEnum,
 	FlowequationIsSSAEnum,
-	FlowequationIsL1L2Enum,
-	FlowequationIsHOEnum,
-	FlowequationIsFSEnum,
-	FlowequationFeFSEnum,
-	FlowequationBorderFSEnum,
-	FrictionAsEnum,
-	FrictionCoefficientEnum,
-	FrictionCoefficientcoulombEnum,
-	FrictionPressureAdjustedTemperatureEnum,
-	FrictionPEnum,
-	FrictionQEnum,
-	FrictionMEnum,
-	FrictionCEnum,
+	FrictionCouplingEnum,
+	FrictionFEnum,
+	FrictionGammaEnum,
 	FrictionLawEnum,
-	FrictionGammaEnum,
-	FrictionFEnum,
-	FrictionWaterLayerEnum,
-	FrictionEffectivePressureEnum,
-	FrictionCouplingEnum,
-	GeometryHydrostaticRatioEnum,
-	HydrologyModelEnum,
-	HydrologyNumRequestedOutputsEnum,
-	HydrologyRequestedOutputsEnum,
-	HydrologyshreveEnum,
-	HydrologyshreveStabilizationEnum,
-	HydrologydcEnum,
-	HydrologydtEnum,
-	HydrologyStepsPerStepEnum,
-	SedimentHeadEnum,
-	SedimentHeadOldEnum,
-	SedimentHeadStackedEnum,
-	SedimentHeadTimeAverageEnum,
-	SedimentHeadResidualEnum,
-	EffectivePressureEnum,
-	EffectivePressureStackedEnum,
-	EffectivePressureTimeAverageEnum,
-	EplHeadEnum,
-	EplHeadOldEnum,
-	EplHeadStackedEnum,
-	EplHeadTimeAverageEnum,
-	EplHeadSlopeXEnum,
-	EplHeadSlopeYEnum,
-	EplZigZagCounterEnum,
+	GiaCrossSectionShapeEnum,
+	GroundinglineMigrationEnum,
+	HydrologydcEplflipLockEnum,
+	HydrologydcEplThickCompEnum,
+	HydrologydcIsefficientlayerEnum,
+	HydrologydcLeakageFactorEnum,
 	HydrologydcMaxIterEnum,
+	HydrologydcPenaltyFactorEnum,
+	HydrologydcPenaltyLockEnum,
 	HydrologydcRelTolEnum,
-	HydrologydcSedimentCompressibilityEnum,
-	HydrologydcSedimentPorosityEnum,
-	HydrologydcSedimentThicknessEnum,
-	HydrologydcSedimentTransmitivityEnum,
-	HydrologydcWaterCompressibilityEnum,
-	HydrologydcMaskEplactiveNodeEnum,
-	HydrologydcMaskEplactiveEltEnum,
-	HydrologydcEplCompressibilityEnum,
-	HydrologydcEplPorosityEnum,
-	HydrologydcEplInitialThicknessEnum,
-	HydrologydcEplColapseThicknessEnum,
-	HydrologydcEplMaxThicknessEnum,
-	HydrologydcEplThicknessEnum,
-	HydrologydcEplThicknessOldEnum,
-	HydrologydcEplThicknessStackedEnum,
-	HydrologydcEplThicknessTimeAverageEnum,
-	HydrologydcEplThickCompEnum,
-	HydrologydcEplConductivityEnum,
-	HydrologydcIsefficientlayerEnum,
+	HydrologydcSedimentlimitEnum,
 	HydrologydcSedimentlimitFlagEnum,
-	HydrologydcSedimentlimitEnum,
 	HydrologydcTransferFlagEnum,
 	HydrologydcUnconfinedFlagEnum,
-	HydrologydcLeakageFactorEnum,
-	HydrologydcPenaltyFactorEnum,
-	HydrologydcPenaltyLockEnum,
-	HydrologydcEplflipLockEnum,
-	HydrologydcBasalMoulinInputEnum,
+	HydrologydtEnum,
+	HydrologyModelEnum,
+	HydrologyNumRequestedOutputsEnum,
+	HydrologyRelaxationEnum,
+	HydrologyRequestedOutputsEnum,
 	HydrologySedimentKmaxEnum,
-	HydrologysommersEnum,
-	HydrologyHeadEnum,
-	HydrologyHeadOldEnum,
-	HydrologyGapHeightEnum,
-	HydrologyBumpSpacingEnum,
-	HydrologyBumpHeightEnum,
-	HydrologyEnglacialInputEnum,
-	HydrologyMoulinInputEnum,
-	HydrologyReynoldsEnum,
-	HydrologyNeumannfluxEnum,
-	HydrologyRelaxationEnum,
-	HydrologyBasalFluxEnum,
+	HydrologyshreveStabilizationEnum,
+	HydrologyStepsPerStepEnum,
 	HydrologyStorageEnum,
-	DegreeOfChannelizationEnum,
+	IcecapToEarthCommEnum,
+	IndexEnum,
+	InputFileNameEnum,
+	InputToDepthaverageInEnum,
+	InputToDepthaverageOutEnum,
+	InputToExtrudeEnum,
+	InputToL2ProjectEnum,
+	InputToSmoothEnum,
+	InversionAlgorithmEnum,
 	InversionControlParametersEnum,
 	InversionControlScalingFactorsEnum,
-	InversionCostFunctionThresholdEnum,
-	InversionCostFunctionsCoefficientsEnum,
 	InversionCostFunctionsEnum,
+	InversionDxminEnum,
+	InversionGatolEnum,
 	InversionGradientScalingEnum,
+	InversionGrtolEnum,
+	InversionGttolEnum,
+	InversionIncompleteAdjointEnum,
 	InversionIscontrolEnum,
-	InversionTypeEnum,
-	InversionIncompleteAdjointEnum,
+	InversionMaxiterEnum,
 	InversionMaxiterPerStepEnum,
-	InversionMaxiterEnum,
 	InversionMaxstepsEnum,
-	InversionFatolEnum,
-	InversionFrtolEnum,
-	InversionGatolEnum,
-	InversionGrtolEnum,
-	InversionGttolEnum,
-	InversionAlgorithmEnum,
 	InversionNstepsEnum,
-	InversionDxminEnum,
 	InversionNumControlParametersEnum,
 	InversionNumCostFunctionsEnum,
 	InversionStepThresholdEnum,
-	InversionThicknessObsEnum,
-	InversionSurfaceObsEnum,
-	InversionVxObsEnum,
-	InversionVyObsEnum,
-	InversionVzObsEnum,
-	InversionVelObsEnum,
-	MaskIceLevelsetEnum,
-	MaskOceanLevelsetEnum,
-	MaskLandLevelsetEnum,
-	MaterialsBetaEnum,
-	MaterialsHeatcapacityEnum,
-	MaterialsLatentheatEnum,
-	MaterialsMeltingpointEnum,
-	MaterialsMixedLayerCapacityEnum,
-	MaterialsRheologyBEnum,
-	MaterialsRheologyBbarEnum,
-	MaterialsRheologyLawEnum,
-	MaterialsRheologyNEnum,
-	MaterialsRheologyEEnum,
-	MaterialsRheologyEbarEnum,
-	MaterialsRheologyEcEnum,
-	MaterialsRheologyEcbarEnum,
-	MaterialsRheologyEsEnum,
-	MaterialsRheologyEsbarEnum,
-	DamageDEnum,
-	DamageFEnum,
-	DamageDbarEnum,
-	DamageLawEnum,
-	DamageC1Enum,
-	DamageC2Enum,
-	DamageC3Enum,
-	DamageC4Enum,
-	DamageElementinterpEnum,
-	DamageHealingEnum,
-	DamageStressThresholdEnum,
-	DamageKappaEnum,
-	DamageStabilizationEnum,
-	DamageMaxiterEnum,
-	DamageMaxDamageEnum,
-	DamageEquivStressEnum,
-	DamageEvolutionNumRequestedOutputsEnum,
-	DamageEvolutionRequestedOutputsEnum,
-	DamageEnum,
-	NewDamageEnum,
-	StressIntensityFactorEnum,
-	CalvingLawEnum,
-	CalvingCalvingrateEnum,
-	CalvingMeltingrateEnum,
-	CalvingHeightAboveFloatationEnum,
-	CalvingLevermannEnum,
-	CalvingVonmisesEnum,
-	CalvingMinthicknessEnum,
-	CalvingHabEnum,
-	CalvingHabFractionEnum,
-	CalvingCrevasseDepthEnum,
-	CalvingDev2Enum,
-	SurfaceCrevasseEnum,
-	BasalCrevasseEnum,
-	CrevasseDepthEnum,
-	WaterheightEnum,
-	DefaultCalvingEnum,
-	CalvinglevermannCoeffEnum,
-	CalvinglevermannMeltingrateEnum,
-	CalvingdevCoeffEnum,
-	CalvingratexEnum,
-	CalvingrateyEnum,
-	CalvingratexAverageEnum,
-	CalvingrateyAverageEnum,
-	CalvingStressThresholdGroundediceEnum,
-	CalvingStressThresholdFloatingiceEnum,
-	CalvingMaxEnum,
-	SigmaVMEnum,
-	StrainRateparallelEnum,
-	StrainRateperpendicularEnum,
-	StrainRateeffectiveEnum,
-	MaterialsRhoIceEnum,
-	MaterialsRhoSeawaterEnum,
-	MaterialsRhoFreshwaterEnum,
-	MaterialsMuWaterEnum,
-	MaterialsThermalExchangeVelocityEnum,
-	MaterialsThermalconductivityEnum,
-	MaterialsTemperateiceconductivityEnum,
-	MaterialsLithosphereShearModulusEnum,
-	MaterialsLithosphereDensityEnum,
-	MaterialsMantleShearModulusEnum,
-	MaterialsMantleDensityEnum,
-	MaterialsEarthDensityEnum,
-	MeshAverageVertexConnectivityEnum,
-	MeshLatEnum,
-	MeshLongEnum,
-	MeshXEnum,
-	MeshYEnum,
-	MeshZEnum,
-	MeshScaleFactorEnum,
-	MeshElementsEnum,
-	MeshNumberofelementsEnum,
-	MeshNumberoflayersEnum,
-	MeshNumberofverticesEnum,
-	MeshVertexonbaseEnum,
-	MeshVertexonsurfaceEnum,
-	MeshVertexonboundaryEnum,
-	MeshElementtypeEnum,
-	DomainTypeEnum,
-	DomainDimensionEnum,
-	Domain2DhorizontalEnum,
-	Domain2DverticalEnum,
-	Domain3DEnum,
-	Domain3DsurfaceEnum,
+	InversionTypeEnum,
+	LevelsetReinitFrequencyEnum,
+	LevelsetStabilizationEnum,
+	LockFileNameEnum,
+	LoveAllowLayerDeletionEnum,
+	LoveForcingTypeEnum,
+	LoveFrequenciesEnum,
+	LoveG0Enum,
+	LoveKernelsEnum,
+	LoveMu0Enum,
+	LoveNfreqEnum,
+	LoveR0Enum,
+	LoveShNmaxEnum,
+	LoveShNminEnum,
+	MassFluxSegmentsEnum,
+	MassFluxSegmentsPresentEnum,
 	MasstransportHydrostaticAdjustmentEnum,
 	MasstransportIsfreesurfaceEnum,
 	MasstransportMinThicknessEnum,
+	MasstransportNumRequestedOutputsEnum,
 	MasstransportPenaltyFactorEnum,
-	MasstransportSpcthicknessEnum,
+	MasstransportRequestedOutputsEnum,
 	MasstransportStabilizationEnum,
-	MasstransportNumRequestedOutputsEnum,
-	MasstransportRequestedOutputsEnum,
+	MeltingOffsetEnum,
+	MeshAverageVertexConnectivityEnum,
+	MeshElementtypeEnum,
+	MeshNumberoflayersEnum,
+	MeshNumberofverticesEnum,
+	ModelIdEnum,
+	NodesEnum,
+	NumModelsEnum,
+	OutputBufferPointerEnum,
+	OutputBufferSizePointerEnum,
+	OutputdefinitionEnum,
+	OutputFileNameEnum,
+	OutputFilePointerEnum,
+	ParamEnum,
+	ParametersEnum,
+	QmuErrNameEnum,
+	QmuInNameEnum,
 	QmuIsdakotaEnum,
-	MassFluxSegmentsEnum,
-	MassFluxSegmentsPresentEnum,
 	QmuNumberofpartitionsEnum,
-	QmuNumberofresponsesEnum,
+	QmuOutNameEnum,
 	QmuPartitionEnum,
 	QmuResponsedescriptorsEnum,
-	QmuVariabledescriptorsEnum,
-	SettingsResultsOnNodesEnum,
+	RestartFileNameEnum,
+	ResultsEnum,
+	RootPathEnum,
+	SaveResultsEnum,
+	SealevelriseAbstolEnum,
+	SealevelriseAngularVelocityEnum,
+	SealevelriseElasticEnum,
+	SealevelriseEquatorialMoiEnum,
+	SealevelriseFluidLoveEnum,
+	SealevelriseGElasticEnum,
+	SealevelriseHElasticEnum,
+	SealevelriseMaxiterEnum,
+	SealevelriseOceanAreaScalingEnum,
+	SealevelrisePolarMoiEnum,
+	SealevelriseReltolEnum,
+	SealevelriseRequestedOutputsEnum,
+	SealevelriseRigidEnum,
+	SealevelriseRotationEnum,
+	SealevelriseTidalLoveHEnum,
+	SealevelriseTidalLoveKEnum,
+	SealevelriseTransitionsEnum,
+	SealevelriseUElasticEnum,
 	SettingsIoGatherEnum,
-	SettingsLowmemEnum,
 	SettingsOutputFrequencyEnum,
 	SettingsRecordingFrequencyEnum,
+	SettingsResultsOnNodesEnum,
+	SettingsSolverResidueThresholdEnum,
 	SettingsWaitonlockEnum,
-	SettingsSolverResidueThresholdEnum,
-	DebugProfilingEnum,
-	ProfilingCurrentMemEnum,
-	ProfilingCurrentFlopsEnum,
-	ProfilingSolutionTimeEnum,
+	SmbAdThreshEnum,
+	SmbAIceEnum,
+	SmbAIdxEnum,
+	SmbASnowEnum,
+	SmbCldFracEnum,
+	SmbDelta18oEnum,
+	SmbDelta18oSurfaceEnum,
+	SmbDenIdxEnum,
+	SmbDtEnum,
+	SmbEnum,
+	SmbFEnum,
+	SmbInitDensityScalingEnum,
+	SmbIsaccumulationEnum,
+	SmbIsalbedoEnum,
+	SmbIsd18opdEnum,
+	SmbIsdelta18oEnum,
+	SmbIsdensificationEnum,
+	SmbIsgraingrowthEnum,
+	SmbIsmeltEnum,
+	SmbIsmungsmEnum,
+	SmbIssetpddfacEnum,
+	SmbIsshortwaveEnum,
+	SmbIstemperaturescaledEnum,
+	SmbIsthermalEnum,
+	SmbIsturbulentfluxEnum,
+	SmbKEnum,
+	SmbNumRequestedOutputsEnum,
+	SmbPfacEnum,
+	SmbRequestedOutputsEnum,
+	SmbSealevEnum,
+	SmbSwIdxEnum,
+	SmbT0dryEnum,
+	SmbT0wetEnum,
+	SmbTdiffEnum,
+	SmbThermoDeltaTScalingEnum,
+	SmoothThicknessMultiplierEnum,
+	SolutionTypeEnum,
 	SteadystateMaxiterEnum,
 	SteadystateNumRequestedOutputsEnum,
 	SteadystateReltolEnum,
 	SteadystateRequestedOutputsEnum,
-	SurfaceEnum,
+	StepEnum,
+	StressbalanceAbstolEnum,
+	StressbalanceFSreconditioningEnum,
+	StressbalanceIsnewtonEnum,
+	StressbalanceMaxiterEnum,
+	StressbalanceNumRequestedOutputsEnum,
+	StressbalancePenaltyFactorEnum,
+	StressbalanceReltolEnum,
+	StressbalanceRequestedOutputsEnum,
+	StressbalanceRestolEnum,
+	StressbalanceRiftPenaltyThresholdEnum,
+	StressbalanceShelfDampeningEnum,
+	ThermalIsdynamicbasalspcEnum,
 	ThermalIsenthalpyEnum,
-	ThermalIsdynamicbasalspcEnum,
-	ThermalReltolEnum,
 	ThermalMaxiterEnum,
+	ThermalNumRequestedOutputsEnum,
 	ThermalPenaltyFactorEnum,
 	ThermalPenaltyLockEnum,
 	ThermalPenaltyThresholdEnum,
-	ThermalSpctemperatureEnum,
+	ThermalReltolEnum,
+	ThermalRequestedOutputsEnum,
 	ThermalStabilizationEnum,
-	ThermalNumRequestedOutputsEnum,
-	ThermalRequestedOutputsEnum,
-	GiaMantleViscosityEnum,
-	GiaLithosphereThicknessEnum,
-	ThicknessEnum,
+	TimeEnum,
+	TimesteppingCflCoefficientEnum,
+	TimesteppingCouplingTimeEnum,
+	TimesteppingFinalTimeEnum,
+	TimesteppingInterpForcingsEnum,
 	TimesteppingStartTimeEnum,
-	TimesteppingFinalTimeEnum,
-	TimesteppingCflCoefficientEnum,
-	TimesteppingTimeAdaptEnum,
 	TimesteppingTimeStepEnum,
-	TimesteppingInterpForcingsEnum,
-	TimesteppingCouplingTimeEnum,
-	TransientIssmbEnum,
+	TimesteppingTimeStepMaxEnum,
+	TimesteppingTimeStepMinEnum,
+	TimesteppingTypeEnum,
+	ToMITgcmCommEnum,
+	ToolkitsFileNameEnum,
+	ToolkitsOptionsAnalysesEnum,
+	ToolkitsOptionsStringsEnum,
+	ToolkitsTypesEnum,
+	TransientAmrFrequencyEnum,
 	TransientIscouplerEnum,
-	TransientIsoceancouplingEnum,
-	TransientIsstressbalanceEnum,
+	TransientIsdamageevolutionEnum,
+	TransientIsesaEnum,
+	TransientIsgiaEnum,
 	TransientIsgroundinglineEnum,
+	TransientIshydrologyEnum,
 	TransientIsmasstransportEnum,
-	TransientIsthermalEnum,
-	TransientIsgiaEnum,
-	TransientIsesaEnum,
-	TransientIsdamageevolutionEnum,
-	TransientIshydrologyEnum,
 	TransientIsmovingfrontEnum,
+	TransientIsoceancouplingEnum,
 	TransientIsslrEnum,
+	TransientIssmbEnum,
+	TransientIsstressbalanceEnum,
+	TransientIsthermalEnum,
 	TransientNumRequestedOutputsEnum,
 	TransientRequestedOutputsEnum,
-	BalancethicknessSpcthicknessEnum,
-	BalancethicknessApparentMassbalanceEnum,
-	BalancethicknessDiffusionCoefficientEnum,
+	VelocityEnum,
+	/*}}}*/
+	ParametersENDEnum,
+	InputsSTARTEnum,
+	/*Inputs{{{*/
+	AdjointEnum,
+	AdjointxEnum,
+	AdjointyEnum,
+	AdjointzEnum,
+	AirEnum,
+	ApproximationEnum,
+	BalancethicknessMisfitEnum,
+	BalancethicknessOmega0Enum,
 	BalancethicknessOmegaEnum,
-	BalancethicknessOmega0Enum,
-	BalancethicknessD0Enum,
-	/*}}}*/
-	/*Smb{{{*/
-	SmbEnum,
-	SmbAnalysisEnum,
-	SmbSolutionEnum,
-	SmbNumRequestedOutputsEnum,
-	SmbRequestedOutputsEnum,
-	SmbIsInitializedEnum,
+	BalancethicknessThickeningRateEnum,
+	BasalforcingsFloatingiceMeltingRateEnum,
+	BasalforcingsGeothermalfluxEnum,
+	BasalforcingsGroundediceMeltingRateEnum,
+	BasalforcingsPicoBasinIdEnum,
+	BasalforcingsPicoBoxIdEnum,
+	BasalforcingsPicoMaxboxcountEnum,
+	BaseEnum,
+	BedEnum,
+	BedSlopeXEnum,
+	BedSlopeYEnum,
+	CalvingCalvingrateEnum,
+	CalvingHabFractionEnum,
+	CalvinglevermannCoeffEnum,
+	CalvinglevermannMeltingrateEnum,
+	CalvingMeltingrateEnum,
+	CalvingratexAverageEnum,
+	CalvingratexEnum,
+	CalvingrateyAverageEnum,
+	CalvingrateyEnum,
+	CalvingStressThresholdFloatingiceEnum,
+	CalvingStressThresholdGroundediceEnum,
+	ConvergedEnum,
+	CrevasseDepthEnum,
+	DamageDbarEnum,
+	DamageDEnum,
+	DamageFEnum,
+	DeviatoricStressxxEnum,
+	DeviatoricStressxyEnum,
+	DeviatoricStressxzEnum,
+	DeviatoricStressyyEnum,
+	DeviatoricStressyzEnum,
+	DeviatoricStresszzEnum,
+	DistanceToCalvingfrontEnum,
+	DistanceToGroundinglineEnum,
+	Domain2DhorizontalEnum,
+	Domain2DverticalEnum,
+	Domain3DEnum,
+	DragCoefficientAbsGradientEnum,
+	DrivingStressXEnum,
+	DrivingStressYEnum,
+	EffectivePressureEnum,
+	EnthalpyEnum,
+	EnthalpyPicardEnum,
+	EplHeadEnum,
+	EplHeadOldEnum,
+	EplHeadSlopeXEnum,
+	EplHeadSlopeYEnum,
+	EsaDeltathicknessEnum,
+	EsaXmotionEnum,
+	EsaYmotionEnum,
+	EtaDiffEnum,
+	FrictionAsEnum,
+	FrictionCEnum,
+	FrictionCoefficientcoulombEnum,
+	FrictionCoefficientEnum,
+	FrictionEffectivePressureEnum,
+	FrictionMEnum,
+	FrictionPEnum,
+	FrictionPressureAdjustedTemperatureEnum,
+	FrictionQEnum,
+	FrictionWaterLayerEnum,
+	GeometryHydrostaticRatioEnum,
+	GiaLithosphereThicknessEnum,
+	GiaMantleViscosityEnum,
+	GradientEnum,
+	HydrologyBumpHeightEnum,
+	HydrologyBumpSpacingEnum,
+	HydrologydcBasalMoulinInputEnum,
+	HydrologydcEplThicknessEnum,
+	HydrologydcEplThicknessOldEnum,
+	HydrologydcMaskEplactiveEltEnum,
+	HydrologydcMaskEplactiveNodeEnum,
+	HydrologydcSedimentTransmitivityEnum,
+	HydrologyEnglacialInputEnum,
+	HydrologyGapHeightEnum,
+	HydrologyHeadEnum,
+	HydrologyHeadOldEnum,
+	HydrologyMoulinInputEnum,
+	HydrologyNeumannfluxEnum,
+	HydrologyReynoldsEnum,
+	HydrologyWaterVxEnum,
+	HydrologyWaterVyEnum,
+	IceEnum,
+	IceMaskNodeActivationEnum,
+	InputEnum,
+	InversionCostFunctionsCoefficientsEnum,
+	InversionSurfaceObsEnum,
+	InversionThicknessObsEnum,
+	InversionVelObsEnum,
+	InversionVxObsEnum,
+	InversionVyObsEnum,
+	LevelsetfunctionSlopeXEnum,
+	LevelsetfunctionSlopeYEnum,
+	LoadingforceXEnum,
+	LoadingforceYEnum,
+	LoadingforceZEnum,
+	MaskGroundediceLevelsetEnum,
+	MaskIceLevelsetEnum,
+	MasstransportSpcthicknessEnum,
+	MaterialsRheologyBbarEnum,
+	MaterialsRheologyBEnum,
+	MaterialsRheologyEbarEnum,
+	MaterialsRheologyEcbarEnum,
+	MaterialsRheologyEcEnum,
+	MaterialsRheologyEEnum,
+	MaterialsRheologyEsbarEnum,
+	MaterialsRheologyEsEnum,
+	MaterialsRheologyNEnum,
+	MeshScaleFactorEnum,
+	MeshVertexonbaseEnum,
+	MeshVertexonboundaryEnum,
+	MeshVertexonsurfaceEnum,
+	MisfitEnum,
+	NeumannfluxEnum,
+	NodeEnum,
+	OmegaAbsGradientEnum,
+	P0Enum,
+	P1Enum,
+	PressureEnum,
+	RheologyBAbsGradientEnum,
+	RheologyBbarAbsGradientEnum,
+	SealevelEnum,
+	SealevelriseDeltathicknessEnum,
+	SedimentHeadEnum,
+	SedimentHeadOldEnum,
+	SedimentHeadResidualEnum,
+	SigmaNNEnum,
+	SmbAccumulationEnum,
+	SmbAEnum,
+	SmbAiniEnum,
+	SmbAValueEnum,
+	SmbBMaxEnum,
+	SmbBMinEnum,
+	SmbBNegEnum,
+	SmbBPosEnum,
+	SmbCEnum,
+	SmbDEnum,
+	SmbDiniEnum,
+	SmbDlwrfEnum,
+	SmbDswrfEnum,
+	SmbDzEnum,
 	SmbDziniEnum,
-	SmbDiniEnum,
-	SmbReiniEnum,
+	SmbDzMinEnum,
+	SmbDzTopEnum,
+	SmbEAirEnum,
+	SmbECEnum,
+	SmbECiniEnum,
+	SmbElaEnum,
+	SmbEvaporationEnum,
+	SmbGdnEnum,
 	SmbGdniniEnum,
+	SmbGspEnum,
 	SmbGspiniEnum,
-	SmbECiniEnum,
-	SmbWiniEnum,
-	SmbAiniEnum,
-	SmbTiniEnum,
-	SmbSizeiniEnum,
-	/*SMBforcing*/
-	SMBforcingEnum,
+	SmbHrefEnum,
+	SmbIsInitializedEnum,
 	SmbMassBalanceEnum,
-	/*SMBgemb*/
-	SMBgembEnum,
-	SmbInitDensityScalingEnum,
-	SmbThermoDeltaTScalingEnum,
-	SmbAdThreshEnum,
-	SmbTaEnum,
-	SmbVEnum,
-	SmbDswrfEnum,
-	SmbDlwrfEnum,
-	SmbPEnum, 
-	SmbEAirEnum, 
+	SmbMeltEnum,
+	SmbMonthlytemperaturesEnum,
 	SmbPAirEnum,
-	SmbTmeanEnum,
-	SmbCEnum,
-	SmbTzEnum,
-	SmbVzEnum, 
-	SmbDtEnum,
-	SmbDzEnum,
-	SmbAIdxEnum,
-	SmbSwIdxEnum,
-	SmbDenIdxEnum,
-	SmbZTopEnum, 
-	SmbDzTopEnum, 
-	SmbDzMinEnum, 
-	SmbZYEnum, 
-	SmbZMaxEnum, 
-	SmbZMinEnum, 
-	SmbOutputFreqEnum, 
-	SmbASnowEnum, 
-	SmbAIceEnum, 
-	SmbCldFracEnum, 
-	SmbT0wetEnum, 
-	SmbT0dryEnum, 
-	SmbKEnum, 
-	SmbDEnum,
+	SmbPddfacIceEnum,
+	SmbPddfacSnowEnum,
+	SmbPEnum,
+	SmbPrecipitationEnum,
+	SmbPrecipitationsLgmEnum,
+	SmbPrecipitationsPresentdayEnum,
 	SmbReEnum,
-	SmbGdnEnum,
-	SmbGspEnum,
-	SmbECEnum,
-	SmbWEnum,
-	SmbAEnum,
-	SmbTEnum,
-	SmbAValueEnum,
-	SmbTeValueEnum,
-	SmbIsgraingrowthEnum,
-	SmbIsalbedoEnum,
-	SmbIsshortwaveEnum,
-	SmbIsthermalEnum,
-	SmbIsaccumulationEnum,
-	SmbIsmeltEnum,
-	SmbIsdensificationEnum,
-	SmbIsturbulentfluxEnum,
-	SmbDzAddEnum,
-	SmbMAddEnum,
-	SmbFACEnum,
-	/*SMBpdd*/
-	SMBpddEnum,	
-	SmbDelta18oEnum,
-	SmbDelta18oSurfaceEnum,
-	SmbIsdelta18oEnum,
-	SmbIssetpddfacEnum,
-	SmbIsmungsmEnum,
-	SmbIsd18opdEnum,
-	SmbIstemperaturescaledEnum,
-	SmbPrecipitationsPresentdayEnum,
-	SmbPrecipitationsLgmEnum,
-	SmbTemperaturesPresentdayEnum,
-	SmbTemperaturesLgmEnum,
-	SmbPrecipitationEnum,
-	SmbPddfacSnowEnum,
-	SmbPddfacIceEnum,
-	SmbDesfacEnum,
+	SmbRefreezeEnum,
+	SmbReiniEnum,
+	SmbRunoffEnum,
 	SmbS0pEnum,
 	SmbS0tEnum,
-	SmbRlapsEnum,
-	SmbRlapslgmEnum,
-	SmbPfacEnum,
-	SmbTdiffEnum,
-	SmbSealevEnum,
-	SMBd18opddEnum,
-	SmbDpermilEnum,
-	SmbFEnum,
-	SMBgradientsEnum,
-	SmbMonthlytemperaturesEnum,
-	SmbHrefEnum,
+	SmbSizeiniEnum,
 	SmbSmbrefEnum,
-	SmbBPosEnum,
-	SmbBNegEnum,
-	SMBhenningEnum,
-	SMBcomponentsEnum,
-	SmbAccumulationEnum,
-	SmbEvaporationEnum,
-	SmbRunoffEnum,
-	SMBmeltcomponentsEnum,
-	SmbMeltEnum,
-	SmbRefreezeEnum,
-	SMBgcmEnum,
-	/*SMBgradientsela*/
-	SMBgradientselaEnum,
-	SmbElaEnum,
-	SmbBMaxEnum,
-	SmbBMinEnum,
-	/*}}}*/
-	/*Inputs {{{*/
-	AdjointpEnum,
-	AdjointxEnum,
-	AdjointyEnum,
-	AdjointzEnum,
-	BalancethicknessMisfitEnum,
-	BedSlopeXEnum,
-	BedSlopeYEnum,
-	BoundaryEnum,
-	ConvergedEnum,
-	InternalEnum,
-	MassFluxEnum,
-	MeltingOffsetEnum,
-	MisfitEnum,
-	PressureEnum,
-	AndroidFrictionCoefficientEnum,
-	ResetPenaltiesEnum,
+	SmbTaEnum,
+	SmbTemperaturesLgmEnum,
+	SmbTemperaturesPresentdayEnum,
+	SmbTEnum,
+	SmbTeValueEnum,
+	SmbTiniEnum,
+	SmbTmeanEnum,
+	SmbTzEnum,
+	SmbVEnum,
+	SmbVzEnum,
+	SmbWEnum,
+	SmbWiniEnum,
+	SmbZMaxEnum,
+	SmbZMinEnum,
+	SmbZTopEnum,
+	SmbZYEnum,
+	StrainRateeffectiveEnum,
+	StrainRateparallelEnum,
+	StrainRateperpendicularEnum,
+	StrainRatexxEnum,
+	StrainRatexyEnum,
+	StrainRatexzEnum,
+	StrainRateyyEnum,
+	StrainRateyzEnum,
+	StrainRatezzEnum,
+	StressMaxPrincipalEnum,
+	StressTensorxxEnum,
+	StressTensorxyEnum,
+	StressTensorxzEnum,
+	StressTensoryyEnum,
+	StressTensoryzEnum,
+	StressTensorzzEnum,
+	SurfaceAbsMisfitEnum,
 	SurfaceAbsVelMisfitEnum,
 	SurfaceAreaEnum,
 	SurfaceAverageVelMisfitEnum,
+	SurfaceEnum,
 	SurfaceLogVelMisfitEnum,
 	SurfaceLogVxVyMisfitEnum,
+	SurfaceObservationEnum,
 	SurfaceRelVelMisfitEnum,
 	SurfaceSlopeXEnum,
 	SurfaceSlopeYEnum,
 	TemperatureEnum,
 	TemperaturePicardEnum,
-	TemperaturePDDEnum,
+	ThicknessAbsGradientEnum,
 	ThicknessAbsMisfitEnum,
-	SurfaceAbsMisfitEnum,
-	OmegaAbsGradientEnum,
-	EtaDiffEnum,
-	EtaAbsGradientEnum,
+	ThicknessAcrossGradientEnum,
+	ThicknessAlongGradientEnum,
+	ThicknessEnum,
+	ThicknessPositiveEnum,
 	VelEnum,
-	VelocityEnum,
 	VxAverageEnum,
 	VxEnum,
+	VxMeshEnum,
+	VxObsEnum,
 	VyAverageEnum,
 	VyEnum,
+	VyMeshEnum,
+	VyObsEnum,
 	VzEnum,
-	VzSSAEnum,
+	VzFSEnum,
 	VzHOEnum,
-	VzFSEnum,
-	VxMeshEnum,
-	VyMeshEnum,
 	VzMeshEnum,
-	EnthalpyEnum,
-	EnthalpyPicardEnum,
-	ThicknessAbsGradientEnum,
-	ThicknessAlongGradientEnum,
-	ThicknessAcrossGradientEnum,
-	ThicknessPositiveEnum,
-	IntMatParamEnum,
-	RheologyBbarAbsGradientEnum,
-	RheologyBAbsGradientEnum,
-	DragCoefficientAbsGradientEnum,
-	TransientInputEnum,
-	WaterfractionEnum,
+	VzSSAEnum,
+	WatercolumnEnum,
+	WaterColumnOldEnum,
 	WaterfractionDrainageEnum,
 	WaterfractionDrainageIntegratedEnum,
-	WatercolumnEnum,
-	ViscousHeatingEnum,
-	HydrologyWaterVxEnum,
-	HydrologyWaterVyEnum,
-	DrivingStressXEnum,
-	DrivingStressYEnum,
-	SigmaNNEnum,
-	StressTensorEnum,
-	StressTensorxxEnum,
-	StressTensorxyEnum,
-	StressTensorxzEnum,
-	StressTensoryyEnum,
-	StressTensoryzEnum,
-	StressTensorzzEnum,
-	StressMaxPrincipalEnum,
-	DeviatoricStressEnum,
-	DeviatoricStressxxEnum,
-	DeviatoricStressxyEnum,
-	DeviatoricStressxzEnum,
-	DeviatoricStressyyEnum,
-	DeviatoricStressyzEnum,
-	DeviatoricStresszzEnum,
+	WaterfractionEnum,
+	WaterheightEnum,
+	WeightsSurfaceObservationEnum,
+	/*}}}*/
+	InputsENDEnum,
+	/*Other{{{*/
+	AbsoluteEnum,
+	AdaptiveTimesteppingEnum,
+	AdjointBalancethickness2AnalysisEnum,
+	AdjointBalancethicknessAnalysisEnum,
+	AdjointHorizAnalysisEnum,
+	AdjointpEnum,
+	AggressiveMigrationEnum,
+	AmrBamgEnum,
+	AmrNeopzEnum,
+	AndroidFrictionCoefficientEnum,
+	ArrheniusEnum,
+	AutodiffJacobianEnum,
+	AutodiffKeepEnum,
+	Balancethickness2AnalysisEnum,
+	Balancethickness2SolutionEnum,
+	BalancethicknessAnalysisEnum,
+	BalancethicknessApparentMassbalanceEnum,
+	BalancethicknessSoftAnalysisEnum,
+	BalancethicknessSoftSolutionEnum,
+	BalancethicknessSolutionEnum,
+	BalancethicknessSpcthicknessEnum,
+	BalancevelocityAnalysisEnum,
+	BalancevelocitySolutionEnum,
+	BasalCrevasseEnum,
+	BasalforcingsPicoEnum,
+	BasalforcingsPicoFarOceantemperatureEnum,
+	BedSlopeSolutionEnum,
+	BoolExternalResultEnum,
+	BoolInputEnum,
+	BoolParamEnum,
+	BoundaryEnum,
+	BuddJackaEnum,
+	CalvingDev2Enum,
+	CalvingHabEnum,
+	CalvingLevermannEnum,
+	CalvingVonmisesEnum,
+	CfsurfacelogvelEnum,
+	CfsurfacesquareEnum,
+	ClosedEnum,
+	ColinearEnum,
+	ConstantsGEnum,
+	ConstantsReferencetemperatureEnum,
+	ConstraintsEnum,
+	ContactEnum,
+	ContourEnum,
+	ContoursEnum,
+	ControlInputEnum,
+	ControlSteadyEnum,
+	CrouzeixRaviartEnum,
+	CuffeyEnum,
+	CuffeyTemperateEnum,
+	DamageC4Enum,
+	DamageElementinterpEnum,
+	DamageEvolutionAnalysisEnum,
+	DamageEvolutionSolutionEnum,
+	DamageMaxiterEnum,
+	DataSetEnum,
+	DatasetInputEnum,
+	DataSetParamEnum,
+	DefaultAnalysisEnum,
+	DefaultCalvingEnum,
+	DegreeOfChannelizationEnum,
+	DenseEnum,
+	DependentObjectEnum,
+	DepthAverageAnalysisEnum,
 	DeviatoricStresseffectiveEnum,
-	LambdaSEnum,
-	StrainRateEnum,
-	StrainRatexxEnum,
-	StrainRatexyEnum,
-	StrainRatexzEnum,
-	StrainRateyyEnum,
-	StrainRateyzEnum,
-	StrainRatezzEnum,
+	DeviatoricStressErrorEstimatorEnum,
 	DivergenceEnum,
-	MaxDivergenceEnum,
-	GiaCrossSectionShapeEnum,
-	GiadWdtEnum,
-	GiaWEnum, 
-	/*}}}*/
-	/*Results{{{*/
-	SaveResultsEnum,
-	BoolExternalResultEnum,
+	Domain3DsurfaceEnum,
+	DoubleArrayInputEnum,
 	DoubleExternalResultEnum,
+	DoubleInputEnum,
+	DoubleMatArrayParamEnum,
 	DoubleMatExternalResultEnum,
+	DoubleMatParamEnum,
+	DoubleParamEnum,
+	DoubleVecParamEnum,
+	EffectivePressureStackedEnum,
+	EffectivePressureTimeAverageEnum,
+	ElementEnum,
+	ElementHookEnum,
+	ElementSIdEnum,
+	EnthalpyAnalysisEnum,
+	EplHeadStackedEnum,
+	EplHeadTimeAverageEnum,
+	EsaAnalysisEnum,
+	EsaEmotionEnum,
+	EsaNmotionEnum,
+	EsaNumRequestedOutputsEnum,
+	EsaRotationrateEnum,
+	EsaSolutionEnum,
+	EsaStrainratexxEnum,
+	EsaStrainratexyEnum,
+	EsaStrainrateyyEnum,
+	EsaTransitionsEnum,
+	EsaUmotionEnum,
+	ExternalResultEnum,
+	ExtrapolationAnalysisEnum,
+	ExtrudeFromBaseAnalysisEnum,
+	ExtrudeFromTopAnalysisEnum,
+	FemModelCommEnum,
+	FemModelEnum,
+	FileParamEnum,
+	FixedTimesteppingEnum,
+	FloatingAreaEnum,
+	FloatingAreaScaledEnum,
+	FloatingMeltRateEnum,
+	FlowequationBorderFSEnum,
+	FreeEnum,
+	FreeSurfaceBaseAnalysisEnum,
+	FreeSurfaceTopAnalysisEnum,
+	FSApproximationEnum,
+	FsetEnum,
+	FSpressureEnum,
+	FSSolverEnum,
+	FSvelocityEnum,
+	GaussPentaEnum,
+	GaussSegEnum,
+	GaussTetraEnum,
+	GaussTriaEnum,
+	GenericOptionEnum,
+	GenericParamEnum,
+	GiadWdtEnum,
+	GiaIvinsAnalysisEnum,
+	GiaSolutionEnum,
+	GiaWEnum,
+	Gradient1Enum,
+	Gradient2Enum,
+	Gradient3Enum,
+	GroundedAreaEnum,
+	GroundedAreaScaledEnum,
+	GroundingOnlyEnum,
+	GsetEnum,
+	GslEnum,
+	HOApproximationEnum,
+	HOFSApproximationEnum,
+	HookEnum,
+	HydrologyBasalFluxEnum,
+	HydrologyDCEfficientAnalysisEnum,
+	HydrologydcEnum,
+	HydrologydcEplColapseThicknessEnum,
+	HydrologydcEplCompressibilityEnum,
+	HydrologydcEplConductivityEnum,
+	HydrologydcEplInitialThicknessEnum,
+	HydrologydcEplMaxThicknessEnum,
+	HydrologydcEplPorosityEnum,
+	HydrologydcEplThicknessStackedEnum,
+	HydrologydcEplThicknessTimeAverageEnum,
+	HydrologyDCInefficientAnalysisEnum,
+	HydrologydcSedimentCompressibilityEnum,
+	HydrologydcSedimentPorosityEnum,
+	HydrologydcSedimentThicknessEnum,
+	HydrologydcWaterCompressibilityEnum,
+	HydrologyShreveAnalysisEnum,
+	HydrologyshreveEnum,
+	HydrologySolutionEnum,
+	HydrologySommersAnalysisEnum,
+	HydrologysommersEnum,
+	IceMassEnum,
+	IceMassScaledEnum,
+	IceVolumeAboveFloatationEnum,
+	IceVolumeAboveFloatationScaledEnum,
+	IceVolumeEnum,
+	IceVolumeScaledEnum,
+	IncrementalEnum,
+	IndexedEnum,
+	InternalEnum,
+	IntersectEnum,
 	IntExternalResultEnum,
+	IntInputEnum,
 	IntMatExternalResultEnum,
+	IntMatParamEnum,
+	IntParamEnum,
+	IntVecParamEnum,
+	InversionCostFunctionThresholdEnum,
+	InversionFatolEnum,
+	InversionFrtolEnum,
+	InversionVzObsEnum,
 	JEnum,
+	L1L2ApproximationEnum,
+	L2ProjectionBaseAnalysisEnum,
+	L2ProjectionEPLAnalysisEnum,
+	LACrouzeixRaviartEnum,
+	LambdaSEnum,
+	LATaylorHoodEnum,
+	LevelsetAnalysisEnum,
+	LevelsetfunctionPicardEnum,
+	LinearFloatingMeltRateEnum,
+	LliboutryDuvalEnum,
+	LoadsEnum,
+	LoveAnalysisEnum,
+	LoveHiEnum,
+	LoveHrEnum,
+	LoveKernelsImagEnum,
+	LoveKernelsRealEnum,
+	LoveKiEnum,
+	LoveKrEnum,
+	LoveLiEnum,
+	LoveLrEnum,
+	LoveSolutionEnum,
+	MantlePlumeGeothermalFluxEnum,
+	MaskLandLevelsetEnum,
+	MaskOceanLevelsetEnum,
+	MassconaxpbyEnum,
+	MassconEnum,
+	MassfluxatgateEnum,
+	MassFluxEnum,
+	MasstransportAnalysisEnum,
+	MasstransportSolutionEnum,
+	MatdamageiceEnum,
+	MatenhancediceEnum,
+	MaterialsBetaEnum,
+	MaterialsEarthDensityEnum,
+	MaterialsEnum,
+	MaterialsHeatcapacityEnum,
+	MaterialsLatentheatEnum,
+	MaterialsLithosphereDensityEnum,
+	MaterialsLithosphereShearModulusEnum,
+	MaterialsMantleDensityEnum,
+	MaterialsMantleShearModulusEnum,
+	MaterialsMeltingpointEnum,
+	MaterialsMixedLayerCapacityEnum,
+	MaterialsMuWaterEnum,
+	MaterialsRheologyLawEnum,
+	MaterialsRhoFreshwaterEnum,
+	MaterialsRhoIceEnum,
+	MaterialsRhoSeawaterEnum,
+	MaterialsTemperateiceconductivityEnum,
+	MaterialsThermalconductivityEnum,
+	MaterialsThermalExchangeVelocityEnum,
+	MatestarEnum,
+	MaticeEnum,
+	MatlithoEnum,
+	MatparEnum,
+	MatrixParamEnum,
+	MaxAbsVxEnum,
+	MaxAbsVyEnum,
+	MaxAbsVzEnum,
+	MaxDivergenceEnum,
+	MaxVelEnum,
+	MaxVxEnum,
+	MaxVyEnum,
+	MaxVzEnum,
+	MelangeEnum,
+	MeltingAnalysisEnum,
+	MeshElementsEnum,
+	MeshLatEnum,
+	MeshLongEnum,
+	MeshNumberofelementsEnum,
+	MeshXEnum,
+	MeshYEnum,
+	MINIcondensedEnum,
+	MINIEnum,
+	MinVelEnum,
+	MinVxEnum,
+	MinVyEnum,
+	MinVzEnum,
+	MismipFloatingMeltRateEnum,
+	MoulinEnum,
+	MpiDenseEnum,
+	MpiEnum,
+	MpiSparseEnum,
+	MumpsEnum,
+	NewDamageEnum,
+	NodalEnum,
+	NodalvalueEnum,
+	NodeSIdEnum,
+	NoneApproximationEnum,
+	NoneEnum,
+	NumberedcostfunctionEnum,
+	NumericalfluxEnum,
+	OldGradientEnum,
+	OneLayerP4zEnum,
+	OpenEnum,
+	OptionEnum,
+	Outputdefinition100Enum,
+	Outputdefinition1Enum,
+	P0ArrayEnum,
+	P1bubblecondensedEnum,
+	P1bubbleEnum,
+	P1DGEnum,
+	P1P1Enum,
+	P1P1GLSEnum,
+	P1xP2Enum,
+	P1xP3Enum,
+	P1xP4Enum,
+	P2bubblecondensedEnum,
+	P2bubbleEnum,
+	P2Enum,
+	P2xP1Enum,
+	P2xP4Enum,
+	PatersonEnum,
+	PengridEnum,
+	PenpairEnum,
+	PentaEnum,
+	PentaInputEnum,
+	ProfilerEnum,
+	ProfilingCurrentFlopsEnum,
+	ProfilingCurrentMemEnum,
+	ProfilingSolutionTimeEnum,
+	QmuNumberofresponsesEnum,
+	QmuVariabledescriptorsEnum,
+	RegionaloutputEnum,
+	RegularEnum,
+	ResetPenaltiesEnum,
+	RiftfrontEnum,
+	ScaledEnum,
+	SealevelAbsoluteEnum,
+	SealevelEmotionEnum,
+	SealevelEustaticEnum,
+	SealevelInertiaTensorXZEnum,
+	SealevelInertiaTensorYZEnum,
+	SealevelInertiaTensorZZEnum,
+	SealevelNmotionEnum,
+	SealevelriseAnalysisEnum,
+	SealevelriseNumRequestedOutputsEnum,
+	SealevelriseSolutionEnum,
+	SealevelriseStericRateEnum,
+	SealevelUmotionEnum,
+	SedimentHeadStackedEnum,
+	SedimentHeadTimeAverageEnum,
+	SegEnum,
+	SegInputEnum,
+	SegmentEnum,
+	SegmentRiftfrontEnum,
+	SeparateEnum,
+	SeqEnum,
+	SettingsLowmemEnum,
+	SIAApproximationEnum,
+	SigmaVMEnum,
+	SmbAnalysisEnum,
+	SMBcomponentsEnum,
+	SMBd18opddEnum,
+	SmbDesfacEnum,
+	SmbDpermilEnum,
+	SmbDzAddEnum,
+	SmbFACEnum,
+	SMBforcingEnum,
+	SMBgcmEnum,
+	SMBgembEnum,
+	SMBgradientselaEnum,
+	SMBgradientsEnum,
+	SMBhenningEnum,
+	SmbMAddEnum,
+	SMBmeltcomponentsEnum,
+	SmbOutputFreqEnum,
+	SMBpddEnum,
+	SmbRlapsEnum,
+	SmbRlapslgmEnum,
+	SmbSolutionEnum,
+	SmoothAnalysisEnum,
+	SoftMigrationEnum,
+	SpcDynamicEnum,
+	SpcStaticEnum,
+	SpcTransientEnum,
+	SSAApproximationEnum,
+	SSAFSApproximationEnum,
+	SSAHOApproximationEnum,
+	SsetEnum,
+	SteadystateSolutionEnum,
+	StressbalanceAnalysisEnum,
+	StressbalanceConvergenceNumStepsEnum,
+	StressbalanceSIAAnalysisEnum,
+	StressbalanceSolutionEnum,
+	StressbalanceVerticalAnalysisEnum,
+	StressIntensityFactorEnum,
+	StringArrayParamEnum,
 	StringExternalResultEnum,
-	StepEnum,
-	TimeEnum,
-	WaterColumnOldEnum,
+	StringParamEnum,
+	SubelementMigration2Enum,
+	SubelementMigration3Enum,
+	SubelementMigrationEnum,
+	SurfaceCrevasseEnum,
+	SurfaceSlopeSolutionEnum,
+	TaylorHoodEnum,
+	TemperaturePDDEnum,
+	TetraEnum,
+	TetraInputEnum,
+	ThermalAnalysisEnum,
+	ThermalSolutionEnum,
+	ThermalSpctemperatureEnum,
+	ThicknessErrorEstimatorEnum,
+	TotalFloatingBmbEnum,
+	TotalFloatingBmbScaledEnum,
+	TotalGroundedBmbEnum,
+	TotalGroundedBmbScaledEnum,
+	TotalSmbEnum,
+	TotalSmbScaledEnum,
+	TransientArrayParamEnum,
+	TransientInputEnum,
+	TransientParamEnum,
+	TransientSolutionEnum,
+	TriaEnum,
+	TriaInputEnum,
+	UzawaPressureAnalysisEnum,
+	VectorParamEnum,
+	VertexEnum,
+	VertexPIdEnum,
+	VertexSIdEnum,
+	VerticesEnum,
+	ViscousHeatingEnum,
+	WaterEnum,
+	WorldCommEnum,
+	XTaylorHoodEnum,
+	XYEnum,
+	XYZEnum,
 	/*}}}*/
-	/*Output Definitions{{{*/
-	SurfaceObservationEnum,
-	WeightsSurfaceObservationEnum,
-	OutputdefinitionEnum,
-	Outputdefinition1Enum,
-	Outputdefinition2Enum,
-	Outputdefinition3Enum,
-	Outputdefinition4Enum,
-	Outputdefinition5Enum,
-	Outputdefinition6Enum,
-	Outputdefinition7Enum,
-	Outputdefinition8Enum,
-	Outputdefinition9Enum,
+	/*Unused?{{{*/
+	BalancethicknessD0Enum,
+	BalancethicknessDiffusionCoefficientEnum,
+	BilinearInterpEnum,
+	CalvingdevCoeffEnum,
+	DeviatoricStressEnum,
+	EtaAbsGradientEnum,
+	MeshZEnum,
+	NearestInterpEnum,
 	Outputdefinition10Enum,
 	Outputdefinition11Enum,
 	Outputdefinition12Enum,
@@ -678,6 +1033,7 @@
 	Outputdefinition27Enum,
 	Outputdefinition28Enum,
 	Outputdefinition29Enum,
+	Outputdefinition2Enum,
 	Outputdefinition30Enum,
 	Outputdefinition31Enum,
 	Outputdefinition32Enum,
@@ -688,6 +1044,7 @@
 	Outputdefinition37Enum,
 	Outputdefinition38Enum,
 	Outputdefinition39Enum,
+	Outputdefinition3Enum,
 	Outputdefinition40Enum,
 	Outputdefinition41Enum,
 	Outputdefinition42Enum,
@@ -698,6 +1055,7 @@
 	Outputdefinition47Enum,
 	Outputdefinition48Enum,
 	Outputdefinition49Enum,
+	Outputdefinition4Enum,
 	Outputdefinition50Enum,
 	Outputdefinition51Enum,
 	Outputdefinition52Enum,
@@ -708,6 +1066,7 @@
 	Outputdefinition57Enum,
 	Outputdefinition58Enum,
 	Outputdefinition59Enum,
+	Outputdefinition5Enum,
 	Outputdefinition60Enum,
 	Outputdefinition61Enum,
 	Outputdefinition62Enum,
@@ -718,6 +1077,7 @@
 	Outputdefinition67Enum,
 	Outputdefinition68Enum,
 	Outputdefinition69Enum,
+	Outputdefinition6Enum,
 	Outputdefinition70Enum,
 	Outputdefinition71Enum,
 	Outputdefinition72Enum,
@@ -728,6 +1088,7 @@
 	Outputdefinition77Enum,
 	Outputdefinition78Enum,
 	Outputdefinition79Enum,
+	Outputdefinition7Enum,
 	Outputdefinition80Enum,
 	Outputdefinition81Enum,
 	Outputdefinition82Enum,
@@ -738,6 +1099,7 @@
 	Outputdefinition87Enum,
 	Outputdefinition88Enum,
 	Outputdefinition89Enum,
+	Outputdefinition8Enum,
 	Outputdefinition90Enum,
 	Outputdefinition91Enum,
 	Outputdefinition92Enum,
@@ -748,432 +1110,17 @@
 	Outputdefinition97Enum,
 	Outputdefinition98Enum,
 	Outputdefinition99Enum,
-	Outputdefinition100Enum,   
+	Outputdefinition9Enum,
 	OutputdefinitionListEnum,
-	MassfluxatgateEnum,
-	NodalvalueEnum,
-	RegionaloutputEnum,
-	VxObsEnum,
-	VyObsEnum,
-	NumberedcostfunctionEnum,
-	CfsurfacesquareEnum,
-	CfsurfacelogvelEnum,
-	/*}}}*/
-	/*Relaxation{{{*/
-	AbsoluteEnum,
-	IncrementalEnum,
-	AugmentedLagrangianREnum,
-	AugmentedLagrangianRhopEnum,
-	AugmentedLagrangianRlambdaEnum,
-	AugmentedLagrangianRholambdaEnum,
-	AugmentedLagrangianThetaEnum,
-	/*}}}*/
-	/*Grounding Line{{{*/
-	NoneEnum,
-	AggressiveMigrationEnum,
-	SoftMigrationEnum,
-	SubelementMigrationEnum,
-	SubelementMigration2Enum,
-	SubelementMigration3Enum,
-	SubelementMigration4Enum,
-	ContactEnum,
-	GroundingOnlyEnum,
-	MaskGroundediceLevelsetEnum,
-	/*}}}*/
-	/*Parameters{{{*/
-	AdjointEnum,
-	ColinearEnum,
-	ControlSteadyEnum,
-	FsetEnum,
-	Gradient1Enum,
-	Gradient2Enum,
-	Gradient3Enum,
-	GradientEnum,
-	GroundinglineMigrationEnum,
-	GsetEnum,
-	IndexEnum,
-	IndexedEnum,
-	IntersectEnum,
-	NodalEnum,
-	OldGradientEnum,
-	OutputBufferPointerEnum,
-	OutputBufferSizePointerEnum,
-	OutputFilePointerEnum,
-	ToolkitsFileNameEnum,
-	RootPathEnum,
-	OutputFileNameEnum,
-	InputFileNameEnum,
-	LockFileNameEnum,
-	RestartFileNameEnum,
-	ToolkitsTypesEnum,
-	ToolkitsOptionsAnalysesEnum,
-	ToolkitsOptionsStringsEnum,
-	QmuErrNameEnum,
-	QmuInNameEnum,
-	QmuOutNameEnum,
-	RegularEnum,
-	ScaledEnum,
-	SeparateEnum,
-	SsetEnum,
-	/*}}}*/
-	/*Toolkits{{{*/
-	DenseEnum,
-	MpiDenseEnum,
-	MpiSparseEnum,
-	SeqEnum,
-	MpiEnum,
-	MumpsEnum,
-	GslEnum,
-	/*}}}*/
-	/*Rheology law (move to Material) {{{*/
-	CuffeyEnum,
-	BuddJackaEnum,
-	CuffeyTemperateEnum,
-	PatersonEnum,
-	ArrheniusEnum,
-	LliboutryDuvalEnum,
-	/*}}}*/
-	/*Levelset related enums (will be moved to appropriate place when finished){{{*/
-	ExtrapolationVariableEnum,
-	IceMaskNodeActivationEnum,
-	LevelsetfunctionSlopeXEnum,
-	LevelsetfunctionSlopeYEnum,
-	LevelsetfunctionPicardEnum,
-	LevelsetReinitFrequencyEnum,
-	/*}}}*/
-	/*Sea Level Rise{{{*/
-	SealevelEnum,
-	SealevelUmotionEnum,
-	SealevelNmotionEnum,
-	SealevelEmotionEnum,
-	SealevelAbsoluteEnum,
-	SealevelEustaticEnum,
-	SealevelInertiaTensorXZEnum,
-	SealevelInertiaTensorYZEnum,
-	SealevelInertiaTensorZZEnum,
 	SealevelObsEnum,
 	SealevelWeightsEnum,
-	SealevelriseDeltathicknessEnum,
-	SealevelriseMaxiterEnum,
-	SealevelriseReltolEnum,
-	SealevelriseAbstolEnum,
-	SealevelriseRigidEnum,
-	SealevelriseElasticEnum,
-	SealevelriseRotationEnum,
-	SealevelriseTidalLoveHEnum,
-	SealevelriseTidalLoveKEnum, 
-	SealevelriseFluidLoveEnum, 
-	SealevelriseEquatorialMoiEnum, 
-	SealevelrisePolarMoiEnum, 
-	SealevelriseAngularVelocityEnum,
-	SealevelriseOceanAreaScalingEnum,
-	SealevelriseStericRateEnum,
-	SealevelriseGElasticEnum,
-	SealevelriseUElasticEnum,
-	SealevelriseHElasticEnum,
-	SealevelriseTransitionsEnum,
-	SealevelriseRequestedOutputsEnum,
-	SealevelriseNumRequestedOutputsEnum,
-	/*}}}*/
-	/*Love Numbers{{{*/
-	LoveNfreqEnum,
-	LoveFrequenciesEnum,
-	LoveShNmaxEnum,
-	LoveShNminEnum,
-	LoveG0Enum,
-	LoveR0Enum,
-	LoveMu0Enum,
-	LoveAllowLayerDeletionEnum,
-	LoveForcingTypeEnum,
-	LoveHrEnum,
-	LoveKrEnum,
-	LoveLrEnum,
-	LoveHiEnum,
-	LoveKiEnum,
-	LoveLiEnum,
-	LoveKernelsEnum,
-	LoveKernelsRealEnum,
-	LoveKernelsImagEnum,
-
-	/*}}}*/
-	/*Elastic adjustment (ESA){{{*/
-	EsaUmotionEnum,
-	EsaNmotionEnum,
-	EsaEmotionEnum,
-	EsaXmotionEnum,
-	EsaYmotionEnum,
-	EsaHemisphereEnum, 
-	EsaStrainratexxEnum,
-   EsaStrainratexyEnum,
-   EsaStrainrateyyEnum,
-   EsaRotationrateEnum,
-	EsaDeltathicknessEnum,
-	EsaUElasticEnum,
-	EsaHElasticEnum,
-	EsaTransitionsEnum,
-	EsaRequestedOutputsEnum,
-	EsaNumRequestedOutputsEnum,
-	/*}}}*/
-	/*Adaptive mesh refinement (AMR){{{*/
-	TransientAmrFrequencyEnum,
-	AmrTypeEnum,
-	AmrRestartEnum,
-	AmrNeopzEnum,
-	AmrLevelMaxEnum,
-	AmrLagEnum,
-	AmrBamgEnum,
-	AmrHminEnum,
-	AmrHmaxEnum,
-	AmrFieldEnum,
-	AmrErrEnum,
-	AmrKeepMetricEnum,
-	AmrGradationEnum,
-	AmrGroundingLineResolutionEnum,
-	AmrGroundingLineDistanceEnum,
-	AmrIceFrontResolutionEnum,
-	AmrIceFrontDistanceEnum,
-	AmrThicknessErrorResolutionEnum,
-	AmrThicknessErrorThresholdEnum,
-	AmrThicknessErrorGroupThresholdEnum,
-	AmrThicknessErrorMaximumEnum,
-	AmrDeviatoricErrorResolutionEnum,
-	AmrDeviatoricErrorThresholdEnum,
-	AmrDeviatoricErrorGroupThresholdEnum,
-	AmrDeviatoricErrorMaximumEnum,
-	DeviatoricStressErrorEstimatorEnum,
-	ThicknessErrorEstimatorEnum,
-	/*}}}*/
-	ParametersENDEnum,
-	/*Approximations {{{*/
-	ApproximationEnum,
-	NoneApproximationEnum,
-	SIAApproximationEnum,
-	SSAApproximationEnum,
-	SSAHOApproximationEnum,
-	SSAFSApproximationEnum,
-	L1L2ApproximationEnum,
-	HOApproximationEnum,
-	HOFSApproximationEnum,
-	FSApproximationEnum,
-	FSvelocityEnum,
-	FSpressureEnum,
-	/*}}}*/
-	InputsENDEnum,
-	/*Coordinate Systems{{{*/
-	XYEnum,
-	XYZEnum,
-	/*}}}*/
-	/*Objects {{{*/
-	GenericParamEnum,
-	BoolInputEnum,
-	BoolParamEnum,
-	ContourEnum,
-	ControlInputEnum,
-	DatasetInputEnum,
-	DoubleInputEnum,
-	DoubleArrayInputEnum,
-	DataSetParamEnum,
-	DoubleMatArrayParamEnum,
-	DoubleMatParamEnum,
-	DoubleParamEnum,
-	DoubleVecParamEnum,
-	ElementEnum,
-	ElementHookEnum,
-	HookEnum,
-	ExternalResultEnum,
-	FileParamEnum,
-	InputEnum,
-	IntInputEnum,
-	IntParamEnum,
-	IntVecParamEnum,
-	TransientParamEnum,
-	TransientArrayParamEnum,
-	MaticeEnum,
-	MatlithoEnum,
-	MatdamageiceEnum,
-	MatenhancediceEnum,
-	MatestarEnum,
-	MatparEnum,
-	NodeEnum,
-	NumericalfluxEnum,
-	NeumannfluxEnum,
-	ParamEnum,
-	MoulinEnum,
-	PengridEnum,
-	PenpairEnum,
-	ProfilerEnum,
-	MatrixParamEnum,
-	MassconEnum,
-	MassconaxpbyEnum,
-	NodeSIdEnum,
-	ElementSIdEnum,
-	VectorParamEnum,
-	RiftfrontEnum,
-	SegmentEnum,
-	SegmentRiftfrontEnum,
-	SpcDynamicEnum,
-	SpcStaticEnum,
-	SpcTransientEnum,
-	StringArrayParamEnum,
-	StringParamEnum,
-	SegEnum,
-	SegInputEnum,
-	TriaEnum,
-	TriaInputEnum,
-	TetraEnum,
-	TetraInputEnum,
-	PentaEnum,
-	PentaInputEnum,
-	VertexEnum,
-	VertexPIdEnum,
-	VertexSIdEnum,
-	/*}}}*/
-	/*Options{{{*/
-	OptionEnum,
-	GenericOptionEnum,
-	/*}}}*/
-	/*Solutions and Analyses{{{ */
-	AdjointBalancethicknessAnalysisEnum,
-	AdjointBalancethickness2AnalysisEnum,
-	AdjointHorizAnalysisEnum,
-	DefaultAnalysisEnum,
-	BalancethicknessAnalysisEnum,
-	BalancethicknessSolutionEnum,
-	Balancethickness2AnalysisEnum,
-	Balancethickness2SolutionEnum,
-	BalancethicknessSoftAnalysisEnum,
-	BalancethicknessSoftSolutionEnum,
-	BalancevelocityAnalysisEnum,
-	BalancevelocitySolutionEnum,
-	L2ProjectionEPLAnalysisEnum,
-	L2ProjectionBaseAnalysisEnum,
-	BedSlopeSolutionEnum,
-	DamageEvolutionSolutionEnum,
-	DamageEvolutionAnalysisEnum,
-	StressbalanceAnalysisEnum,
-	StressbalanceSIAAnalysisEnum,
-	StressbalanceSolutionEnum,
-	StressbalanceVerticalAnalysisEnum,
-	EnthalpyAnalysisEnum,
-	HydrologyShreveAnalysisEnum,
-	HydrologyDCInefficientAnalysisEnum,
-	HydrologyDCEfficientAnalysisEnum,
-	HydrologySommersAnalysisEnum,
-	HydrologySolutionEnum,
-	MeltingAnalysisEnum,
-	MasstransportAnalysisEnum,
-	MasstransportSolutionEnum,
-	FreeSurfaceBaseAnalysisEnum,
-	FreeSurfaceTopAnalysisEnum,
-	ExtrudeFromBaseAnalysisEnum,
-	ExtrudeFromTopAnalysisEnum,
-	DepthAverageAnalysisEnum,
-	SealevelriseSolutionEnum,
-	SealevelriseAnalysisEnum,
-	SteadystateSolutionEnum,
-	SurfaceSlopeSolutionEnum,
-	SmoothAnalysisEnum,
-	ThermalAnalysisEnum,
-	ThermalSolutionEnum,
-	TransientSolutionEnum,
-	UzawaPressureAnalysisEnum,
-	GiaSolutionEnum,
-	GiaIvinsAnalysisEnum,
-	EsaSolutionEnum,
-	EsaAnalysisEnum,
-	LoveSolutionEnum,
-	LoveAnalysisEnum,
-	LevelsetAnalysisEnum,
-	ExtrapolationAnalysisEnum,
-	/*}}}*/
-	/*Gauss{{{*/
-	GaussSegEnum,
-	GaussTriaEnum,
-	GaussTetraEnum,
-	GaussPentaEnum,
-	/*}}}*/
-	/*Interpolation {{{*/
+	StrainRateEnum,
+	StressbalanceViscosityOvershootEnum,
+	StressTensorEnum,
+	SubelementMigration4Enum,
+	TimesteppingTimeAdaptEnum,
 	TriangleInterpEnum,
-	BilinearInterpEnum,
-	NearestInterpEnum,
 	/*}}}*/
-	/*Responses{{{*/
-	MinVelEnum,
-	MaxVelEnum,
-	MinVxEnum,
-	MaxVxEnum,
-	MaxAbsVxEnum,
-	MinVyEnum,
-	MaxVyEnum,
-	MaxAbsVyEnum,
-	MinVzEnum,
-	MaxVzEnum,
-	MaxAbsVzEnum,
-	FloatingAreaEnum,
-	FloatingAreaScaledEnum,
-	GroundedAreaEnum,
-	GroundedAreaScaledEnum,
-	IceMassEnum,
-	IceMassScaledEnum,
-	IceVolumeEnum,
-	IceVolumeScaledEnum,
-	IceVolumeAboveFloatationEnum,
-	IceVolumeAboveFloatationScaledEnum,
-	TotalFloatingBmbEnum,
-	TotalFloatingBmbScaledEnum,
-	TotalGroundedBmbEnum,
-	TotalGroundedBmbScaledEnum,
-	TotalSmbEnum,
-	TotalSmbScaledEnum,
-	/*}}}*/
-	/*Element Interpolations{{{*/
-	P0Enum,
-	P0ArrayEnum,
-	P1Enum,
-	P1DGEnum,
-	P1bubbleEnum,
-	P1bubblecondensedEnum,
-	P2Enum,
-	P2bubbleEnum,
-	P2bubblecondensedEnum,
-	P2xP1Enum,
-	P1xP2Enum,
-	P1xP3Enum,
-	P1xP4Enum,
-	P2xP4Enum,
-	P1P1Enum,
-	P1P1GLSEnum,
-	MINIEnum,
-	MINIcondensedEnum,
-	TaylorHoodEnum,
-	LATaylorHoodEnum,
-	XTaylorHoodEnum,
-	OneLayerP4zEnum,
-	CrouzeixRaviartEnum,
-	LACrouzeixRaviartEnum,
-	/*}}}*/
-	/*Rift state {{{*/
-	ClosedEnum,
-	FreeEnum,
-	OpenEnum,
-	/*}}}*/
-	/*Fill {{{*/
-	AirEnum,
-	IceEnum,
-	MelangeEnum,
-	WaterEnum,
-	/*}}}*/
-	/*Datasets {{{*/
-	DataSetEnum,
-	ConstraintsEnum,
-	LoadsEnum,
-	MaterialsEnum,
-	NodesEnum,
-	ContoursEnum,
-	ParametersEnum,
-	VerticesEnum,
-	ResultsEnum,
-	/*}}}*/
 	MaximumNumberOfDefinitionsEnum
 };
 
Index: ../trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp
===================================================================
--- ../trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp	(revision 22595)
+++ ../trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp	(revision 22596)
@@ -16,642 +16,1005 @@
 
 	switch(en){
 
-		case FemModelEnum : return "FemModel";
 		case ParametersSTARTEnum : return "ParametersSTART";
 		case AdolcParamEnum : return "AdolcParam";
-		case FSSolverEnum : return "FSSolver";
-		case FemModelCommEnum : return "FemModelComm";
-		case WorldCommEnum : return "WorldComm";
-		case IcecapToEarthCommEnum : return "IcecapToEarthComm";
-		case ToMITgcmCommEnum : return "ToMITgcmComm";
-		case NumModelsEnum : return "NumModels";
-		case ModelIdEnum : return "ModelId";
-		case EarthIdEnum : return "EarthId";
-		case SolutionTypeEnum : return "SolutionType";
+		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 AnalysisCounterEnum : return "AnalysisCounter";
-		case ConfigurationTypeEnum : return "ConfigurationType";
-		case InputToExtrudeEnum : return "InputToExtrude";
-		case InputToL2ProjectEnum : return "InputToL2Project";
-		case InputToDepthaverageInEnum : return "InputToDepthaverageIn";
-		case InputToDepthaverageOutEnum : return "InputToDepthaverageOut";
-		case InputToSmoothEnum : return "InputToSmooth";
-		case SmoothThicknessMultiplierEnum : return "SmoothThicknessMultiplier";
-		case LevelsetStabilizationEnum : return "LevelsetStabilization";
-		case TimesteppingTypeEnum : return "TimesteppingType";
-		case FixedTimesteppingEnum : return "FixedTimestepping";
-		case AdaptiveTimesteppingEnum : return "AdaptiveTimestepping";
-		case TimesteppingTimeStepMinEnum : return "TimesteppingTimeStepMin";
-		case TimesteppingTimeStepMaxEnum : return "TimesteppingTimeStepMax";
-		case InputsSTARTEnum : return "InputsSTART";
-		case AutodiffIsautodiffEnum : return "AutodiffIsautodiff";
-		case AutodiffNumDependentsEnum : return "AutodiffNumDependents";
+		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 AutodiffNumIndependentsEnum : return "AutodiffNumIndependents";
-		case AutodiffJacobianEnum : return "AutodiffJacobian";
-		case AutodiffXpEnum : return "AutodiffXp";
 		case AutodiffDriverEnum : return "AutodiffDriver";
 		case AutodiffFosForwardIndexEnum : return "AutodiffFosForwardIndex";
+		case AutodiffFosReverseIndexEnum : return "AutodiffFosReverseIndex";
 		case AutodiffFovForwardIndicesEnum : return "AutodiffFovForwardIndices";
-		case AutodiffFosReverseIndexEnum : return "AutodiffFosReverseIndex";
-		case AutodiffKeepEnum : return "AutodiffKeep";
+		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 AutodiffLbufsizeEnum : return "AutodiffLbufsize";
-		case AutodiffCbufsizeEnum : return "AutodiffCbufsize";
 		case AutodiffTbufsizeEnum : return "AutodiffTbufsize";
-		case AutodiffGcTriggerRatioEnum : return "AutodiffGcTriggerRatio";
-		case AutodiffGcTriggerMaxSizeEnum : return "AutodiffGcTriggerMaxSize";
+		case AutodiffXpEnum : return "AutodiffXp";
 		case BalancethicknessStabilizationEnum : return "BalancethicknessStabilization";
-		case BalancethicknessThickeningRateEnum : return "BalancethicknessThickeningRate";
+		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 BasalforcingsGeothermalfluxEnum : return "BasalforcingsGeothermalflux";
-		case BasalforcingsGroundediceMeltingRateEnum : return "BasalforcingsGroundediceMeltingRate";
-		case BasalforcingsFloatingiceMeltingRateEnum : return "BasalforcingsFloatingiceMeltingRate";
-		case BasalforcingsDeepwaterMeltingRateEnum : return "BasalforcingsDeepwaterMeltingRate";
-		case BasalforcingsDeepwaterElevationEnum : return "BasalforcingsDeepwaterElevation";
-		case BasalforcingsUpperwaterElevationEnum : return "BasalforcingsUpperwaterElevation";
+		case BasalforcingsLowercrustheatEnum : return "BasalforcingsLowercrustheat";
+		case BasalforcingsMantleconductivityEnum : return "BasalforcingsMantleconductivity";
 		case BasalforcingsMeltrateFactorEnum : return "BasalforcingsMeltrateFactor";
-		case BasalforcingsThresholdThicknessEnum : return "BasalforcingsThresholdThickness";
-		case BasalforcingsUpperdepthMeltEnum : return "BasalforcingsUpperdepthMelt";
-		case BasalforcingsMantleconductivityEnum : return "BasalforcingsMantleconductivity";
 		case BasalforcingsNusseltEnum : return "BasalforcingsNusselt";
-		case BasalforcingsDtbgEnum : return "BasalforcingsDtbg";
+		case BasalforcingsPicoFarOceansalinityEnum : return "BasalforcingsPicoFarOceansalinity";
+		case BasalforcingsPicoGammaTEnum : return "BasalforcingsPicoGammaT";
+		case BasalforcingsPicoNumBasinsEnum : return "BasalforcingsPicoNumBasins";
+		case BasalforcingsPicoOverturningCoeffEnum : return "BasalforcingsPicoOverturningCoeff";
 		case BasalforcingsPlumeradiusEnum : return "BasalforcingsPlumeradius";
-		case BasalforcingsTopplumedepthEnum : return "BasalforcingsTopplumedepth";
-		case BasalforcingsBottomplumedepthEnum : return "BasalforcingsBottomplumedepth";
 		case BasalforcingsPlumexEnum : return "BasalforcingsPlumex";
 		case BasalforcingsPlumeyEnum : return "BasalforcingsPlumey";
-		case BasalforcingsCrustthicknessEnum : return "BasalforcingsCrustthickness";
+		case BasalforcingsThresholdThicknessEnum : return "BasalforcingsThresholdThickness";
+		case BasalforcingsTopplumedepthEnum : return "BasalforcingsTopplumedepth";
+		case BasalforcingsUppercrustheatEnum : return "BasalforcingsUppercrustheat";
 		case BasalforcingsUppercrustthicknessEnum : return "BasalforcingsUppercrustthickness";
-		case BasalforcingsUppercrustheatEnum : return "BasalforcingsUppercrustheat";
-		case BasalforcingsLowercrustheatEnum : return "BasalforcingsLowercrustheat";
-		case FloatingMeltRateEnum : return "FloatingMeltRate";
-		case LinearFloatingMeltRateEnum : return "LinearFloatingMeltRate";
-		case MismipFloatingMeltRateEnum : return "MismipFloatingMeltRate";
-		case MantlePlumeGeothermalFluxEnum : return "MantlePlumeGeothermalFlux";
-		case BasalforcingsPicoEnum : return "BasalforcingsPico";
-		case BasalforcingsPicoNumBasinsEnum : return "BasalforcingsPicoNumBasins";
-		case BasalforcingsPicoBasinIdEnum : return "BasalforcingsPicoBasinId";
-		case BasalforcingsPicoMaxboxcountEnum : return "BasalforcingsPicoMaxboxcount";
-		case BasalforcingsPicoBoxIdEnum : return "BasalforcingsPicoBoxId";
-		case BasalforcingsPicoOverturningCoeffEnum : return "BasalforcingsPicoOverturningCoeff";
-		case BasalforcingsPicoGammaTEnum : return "BasalforcingsPicoGammaT";
-		case BasalforcingsPicoFarOceantemperatureEnum : return "BasalforcingsPicoFarOceantemperature";
-		case BasalforcingsPicoFarOceansalinityEnum : return "BasalforcingsPicoFarOceansalinity";
-		case DistanceToGroundinglineEnum : return "DistanceToGroundingline";
-		case DistanceToCalvingfrontEnum : return "DistanceToCalvingfront";
-		case BedEnum : return "Bed";
-		case BaseEnum : return "Base";
-		case ConstantsGEnum : return "ConstantsG";
-		case ConstantsReferencetemperatureEnum : return "ConstantsReferencetemperature";
+		case BasalforcingsUpperdepthMeltEnum : return "BasalforcingsUpperdepthMelt";
+		case BasalforcingsUpperwaterElevationEnum : return "BasalforcingsUpperwaterElevation";
+		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 ConstantsYtsEnum : return "ConstantsYts";
-		case DependentObjectEnum : return "DependentObject";
-		case StressbalanceAbstolEnum : return "StressbalanceAbstol";
-		case StressbalanceConvergenceNumStepsEnum : return "StressbalanceConvergenceNumSteps";
-		case StressbalanceIsnewtonEnum : return "StressbalanceIsnewton";
-		case StressbalanceMaxiterEnum : return "StressbalanceMaxiter";
-		case StressbalancePenaltyFactorEnum : return "StressbalancePenaltyFactor";
-		case StressbalanceReltolEnum : return "StressbalanceReltol";
-		case StressbalanceNumRequestedOutputsEnum : return "StressbalanceNumRequestedOutputs";
-		case StressbalanceRequestedOutputsEnum : return "StressbalanceRequestedOutputs";
-		case StressbalanceRestolEnum : return "StressbalanceRestol";
-		case StressbalanceRiftPenaltyThresholdEnum : return "StressbalanceRiftPenaltyThreshold";
-		case StressbalanceShelfDampeningEnum : return "StressbalanceShelfDampening";
-		case StressbalanceFSreconditioningEnum : return "StressbalanceFSreconditioning";
-		case StressbalanceViscosityOvershootEnum : return "StressbalanceViscosityOvershoot";
-		case LoadingforceXEnum : return "LoadingforceX";
-		case LoadingforceYEnum : return "LoadingforceY";
-		case LoadingforceZEnum : return "LoadingforceZ";
+		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 FlowequationFeFSEnum : return "FlowequationFeFS";
+		case FlowequationIsFSEnum : return "FlowequationIsFS";
+		case FlowequationIsHOEnum : return "FlowequationIsHO";
+		case FlowequationIsL1L2Enum : return "FlowequationIsL1L2";
 		case FlowequationIsSIAEnum : return "FlowequationIsSIA";
 		case FlowequationIsSSAEnum : return "FlowequationIsSSA";
-		case FlowequationIsL1L2Enum : return "FlowequationIsL1L2";
-		case FlowequationIsHOEnum : return "FlowequationIsHO";
-		case FlowequationIsFSEnum : return "FlowequationIsFS";
-		case FlowequationFeFSEnum : return "FlowequationFeFS";
-		case FlowequationBorderFSEnum : return "FlowequationBorderFS";
-		case FrictionAsEnum : return "FrictionAs";
-		case FrictionCoefficientEnum : return "FrictionCoefficient";
-		case FrictionCoefficientcoulombEnum : return "FrictionCoefficientcoulomb";
-		case FrictionPressureAdjustedTemperatureEnum : return "FrictionPressureAdjustedTemperature";
-		case FrictionPEnum : return "FrictionP";
-		case FrictionQEnum : return "FrictionQ";
-		case FrictionMEnum : return "FrictionM";
-		case FrictionCEnum : return "FrictionC";
+		case FrictionCouplingEnum : return "FrictionCoupling";
+		case FrictionFEnum : return "FrictionF";
+		case FrictionGammaEnum : return "FrictionGamma";
 		case FrictionLawEnum : return "FrictionLaw";
-		case FrictionGammaEnum : return "FrictionGamma";
-		case FrictionFEnum : return "FrictionF";
-		case FrictionWaterLayerEnum : return "FrictionWaterLayer";
-		case FrictionEffectivePressureEnum : return "FrictionEffectivePressure";
-		case FrictionCouplingEnum : return "FrictionCoupling";
-		case GeometryHydrostaticRatioEnum : return "GeometryHydrostaticRatio";
-		case HydrologyModelEnum : return "HydrologyModel";
-		case HydrologyNumRequestedOutputsEnum : return "HydrologyNumRequestedOutputs";
-		case HydrologyRequestedOutputsEnum : return "HydrologyRequestedOutputs";
-		case HydrologyshreveEnum : return "Hydrologyshreve";
-		case HydrologyshreveStabilizationEnum : return "HydrologyshreveStabilization";
-		case HydrologydcEnum : return "Hydrologydc";
-		case HydrologydtEnum : return "Hydrologydt";
-		case HydrologyStepsPerStepEnum : return "HydrologyStepsPerStep";
-		case SedimentHeadEnum : return "SedimentHead";
-		case SedimentHeadOldEnum : return "SedimentHeadOld";
-		case SedimentHeadStackedEnum : return "SedimentHeadStacked";
-		case SedimentHeadTimeAverageEnum : return "SedimentHeadTimeAverage";
-		case SedimentHeadResidualEnum : return "SedimentHeadResidual";
-		case EffectivePressureEnum : return "EffectivePressure";
-		case EffectivePressureStackedEnum : return "EffectivePressureStacked";
-		case EffectivePressureTimeAverageEnum : return "EffectivePressureTimeAverage";
-		case EplHeadEnum : return "EplHead";
-		case EplHeadOldEnum : return "EplHeadOld";
-		case EplHeadStackedEnum : return "EplHeadStacked";
-		case EplHeadTimeAverageEnum : return "EplHeadTimeAverage";
-		case EplHeadSlopeXEnum : return "EplHeadSlopeX";
-		case EplHeadSlopeYEnum : return "EplHeadSlopeY";
-		case EplZigZagCounterEnum : return "EplZigZagCounter";
+		case GiaCrossSectionShapeEnum : return "GiaCrossSectionShape";
+		case GroundinglineMigrationEnum : return "GroundinglineMigration";
+		case HydrologydcEplflipLockEnum : return "HydrologydcEplflipLock";
+		case HydrologydcEplThickCompEnum : return "HydrologydcEplThickComp";
+		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 HydrologydcSedimentTransmitivityEnum : return "HydrologydcSedimentTransmitivity";
-		case HydrologydcWaterCompressibilityEnum : return "HydrologydcWaterCompressibility";
-		case HydrologydcMaskEplactiveNodeEnum : return "HydrologydcMaskEplactiveNode";
-		case HydrologydcMaskEplactiveEltEnum : return "HydrologydcMaskEplactiveElt";
-		case HydrologydcEplCompressibilityEnum : return "HydrologydcEplCompressibility";
-		case HydrologydcEplPorosityEnum : return "HydrologydcEplPorosity";
-		case HydrologydcEplInitialThicknessEnum : return "HydrologydcEplInitialThickness";
-		case HydrologydcEplColapseThicknessEnum : return "HydrologydcEplColapseThickness";
-		case HydrologydcEplMaxThicknessEnum : return "HydrologydcEplMaxThickness";
-		case HydrologydcEplThicknessEnum : return "HydrologydcEplThickness";
-		case HydrologydcEplThicknessOldEnum : return "HydrologydcEplThicknessOld";
-		case HydrologydcEplThicknessStackedEnum : return "HydrologydcEplThicknessStacked";
-		case HydrologydcEplThicknessTimeAverageEnum : return "HydrologydcEplThicknessTimeAverage";
-		case HydrologydcEplThickCompEnum : return "HydrologydcEplThickComp";
-		case HydrologydcEplConductivityEnum : return "HydrologydcEplConductivity";
-		case HydrologydcIsefficientlayerEnum : return "HydrologydcIsefficientlayer";
+		case HydrologydcSedimentlimitEnum : return "HydrologydcSedimentlimit";
 		case HydrologydcSedimentlimitFlagEnum : return "HydrologydcSedimentlimitFlag";
-		case HydrologydcSedimentlimitEnum : return "HydrologydcSedimentlimit";
 		case HydrologydcTransferFlagEnum : return "HydrologydcTransferFlag";
 		case HydrologydcUnconfinedFlagEnum : return "HydrologydcUnconfinedFlag";
-		case HydrologydcLeakageFactorEnum : return "HydrologydcLeakageFactor";
-		case HydrologydcPenaltyFactorEnum : return "HydrologydcPenaltyFactor";
-		case HydrologydcPenaltyLockEnum : return "HydrologydcPenaltyLock";
-		case HydrologydcEplflipLockEnum : return "HydrologydcEplflipLock";
-		case HydrologydcBasalMoulinInputEnum : return "HydrologydcBasalMoulinInput";
+		case HydrologydtEnum : return "Hydrologydt";
+		case HydrologyModelEnum : return "HydrologyModel";
+		case HydrologyNumRequestedOutputsEnum : return "HydrologyNumRequestedOutputs";
+		case HydrologyRelaxationEnum : return "HydrologyRelaxation";
+		case HydrologyRequestedOutputsEnum : return "HydrologyRequestedOutputs";
 		case HydrologySedimentKmaxEnum : return "HydrologySedimentKmax";
-		case HydrologysommersEnum : return "Hydrologysommers";
-		case HydrologyHeadEnum : return "HydrologyHead";
-		case HydrologyHeadOldEnum : return "HydrologyHeadOld";
-		case HydrologyGapHeightEnum : return "HydrologyGapHeight";
-		case HydrologyBumpSpacingEnum : return "HydrologyBumpSpacing";
-		case HydrologyBumpHeightEnum : return "HydrologyBumpHeight";
-		case HydrologyEnglacialInputEnum : return "HydrologyEnglacialInput";
-		case HydrologyMoulinInputEnum : return "HydrologyMoulinInput";
-		case HydrologyReynoldsEnum : return "HydrologyReynolds";
-		case HydrologyNeumannfluxEnum : return "HydrologyNeumannflux";
-		case HydrologyRelaxationEnum : return "HydrologyRelaxation";
-		case HydrologyBasalFluxEnum : return "HydrologyBasalFlux";
+		case HydrologyshreveStabilizationEnum : return "HydrologyshreveStabilization";
+		case HydrologyStepsPerStepEnum : return "HydrologyStepsPerStep";
 		case HydrologyStorageEnum : return "HydrologyStorage";
-		case DegreeOfChannelizationEnum : return "DegreeOfChannelization";
+		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 InversionCostFunctionThresholdEnum : return "InversionCostFunctionThreshold";
-		case InversionCostFunctionsCoefficientsEnum : return "InversionCostFunctionsCoefficients";
 		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 InversionTypeEnum : return "InversionType";
-		case InversionIncompleteAdjointEnum : return "InversionIncompleteAdjoint";
+		case InversionMaxiterEnum : return "InversionMaxiter";
 		case InversionMaxiterPerStepEnum : return "InversionMaxiterPerStep";
-		case InversionMaxiterEnum : return "InversionMaxiter";
 		case InversionMaxstepsEnum : return "InversionMaxsteps";
-		case InversionFatolEnum : return "InversionFatol";
-		case InversionFrtolEnum : return "InversionFrtol";
-		case InversionGatolEnum : return "InversionGatol";
-		case InversionGrtolEnum : return "InversionGrtol";
-		case InversionGttolEnum : return "InversionGttol";
-		case InversionAlgorithmEnum : return "InversionAlgorithm";
 		case InversionNstepsEnum : return "InversionNsteps";
-		case InversionDxminEnum : return "InversionDxmin";
 		case InversionNumControlParametersEnum : return "InversionNumControlParameters";
 		case InversionNumCostFunctionsEnum : return "InversionNumCostFunctions";
 		case InversionStepThresholdEnum : return "InversionStepThreshold";
-		case InversionThicknessObsEnum : return "InversionThicknessObs";
-		case InversionSurfaceObsEnum : return "InversionSurfaceObs";
-		case InversionVxObsEnum : return "InversionVxObs";
-		case InversionVyObsEnum : return "InversionVyObs";
-		case InversionVzObsEnum : return "InversionVzObs";
-		case InversionVelObsEnum : return "InversionVelObs";
-		case MaskIceLevelsetEnum : return "MaskIceLevelset";
-		case MaskOceanLevelsetEnum : return "MaskOceanLevelset";
-		case MaskLandLevelsetEnum : return "MaskLandLevelset";
-		case MaterialsBetaEnum : return "MaterialsBeta";
-		case MaterialsHeatcapacityEnum : return "MaterialsHeatcapacity";
-		case MaterialsLatentheatEnum : return "MaterialsLatentheat";
-		case MaterialsMeltingpointEnum : return "MaterialsMeltingpoint";
-		case MaterialsMixedLayerCapacityEnum : return "MaterialsMixedLayerCapacity";
-		case MaterialsRheologyBEnum : return "MaterialsRheologyB";
-		case MaterialsRheologyBbarEnum : return "MaterialsRheologyBbar";
-		case MaterialsRheologyLawEnum : return "MaterialsRheologyLaw";
-		case MaterialsRheologyNEnum : return "MaterialsRheologyN";
-		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 DamageDEnum : return "DamageD";
-		case DamageFEnum : return "DamageF";
-		case DamageDbarEnum : return "DamageDbar";
-		case DamageLawEnum : return "DamageLaw";
-		case DamageC1Enum : return "DamageC1";
-		case DamageC2Enum : return "DamageC2";
-		case DamageC3Enum : return "DamageC3";
-		case DamageC4Enum : return "DamageC4";
-		case DamageElementinterpEnum : return "DamageElementinterp";
-		case DamageHealingEnum : return "DamageHealing";
-		case DamageStressThresholdEnum : return "DamageStressThreshold";
-		case DamageKappaEnum : return "DamageKappa";
-		case DamageStabilizationEnum : return "DamageStabilization";
-		case DamageMaxiterEnum : return "DamageMaxiter";
-		case DamageMaxDamageEnum : return "DamageMaxDamage";
-		case DamageEquivStressEnum : return "DamageEquivStress";
-		case DamageEvolutionNumRequestedOutputsEnum : return "DamageEvolutionNumRequestedOutputs";
-		case DamageEvolutionRequestedOutputsEnum : return "DamageEvolutionRequestedOutputs";
-		case DamageEnum : return "Damage";
-		case NewDamageEnum : return "NewDamage";
-		case StressIntensityFactorEnum : return "StressIntensityFactor";
-		case CalvingLawEnum : return "CalvingLaw";
-		case CalvingCalvingrateEnum : return "CalvingCalvingrate";
-		case CalvingMeltingrateEnum : return "CalvingMeltingrate";
-		case CalvingHeightAboveFloatationEnum : return "CalvingHeightAboveFloatation";
-		case CalvingLevermannEnum : return "CalvingLevermann";
-		case CalvingVonmisesEnum : return "CalvingVonmises";
-		case CalvingMinthicknessEnum : return "CalvingMinthickness";
-		case CalvingHabEnum : return "CalvingHab";
-		case CalvingHabFractionEnum : return "CalvingHabFraction";
-		case CalvingCrevasseDepthEnum : return "CalvingCrevasseDepth";
-		case CalvingDev2Enum : return "CalvingDev2";
-		case SurfaceCrevasseEnum : return "SurfaceCrevasse";
-		case BasalCrevasseEnum : return "BasalCrevasse";
-		case CrevasseDepthEnum : return "CrevasseDepth";
-		case WaterheightEnum : return "Waterheight";
-		case DefaultCalvingEnum : return "DefaultCalving";
-		case CalvinglevermannCoeffEnum : return "CalvinglevermannCoeff";
-		case CalvinglevermannMeltingrateEnum : return "CalvinglevermannMeltingrate";
-		case CalvingdevCoeffEnum : return "CalvingdevCoeff";
-		case CalvingratexEnum : return "Calvingratex";
-		case CalvingrateyEnum : return "Calvingratey";
-		case CalvingratexAverageEnum : return "CalvingratexAverage";
-		case CalvingrateyAverageEnum : return "CalvingrateyAverage";
-		case CalvingStressThresholdGroundediceEnum : return "CalvingStressThresholdGroundedice";
-		case CalvingStressThresholdFloatingiceEnum : return "CalvingStressThresholdFloatingice";
-		case CalvingMaxEnum : return "CalvingMax";
-		case SigmaVMEnum : return "SigmaVM";
-		case StrainRateparallelEnum : return "StrainRateparallel";
-		case StrainRateperpendicularEnum : return "StrainRateperpendicular";
-		case StrainRateeffectiveEnum : return "StrainRateeffective";
-		case MaterialsRhoIceEnum : return "MaterialsRhoIce";
-		case MaterialsRhoSeawaterEnum : return "MaterialsRhoSeawater";
-		case MaterialsRhoFreshwaterEnum : return "MaterialsRhoFreshwater";
-		case MaterialsMuWaterEnum : return "MaterialsMuWater";
-		case MaterialsThermalExchangeVelocityEnum : return "MaterialsThermalExchangeVelocity";
-		case MaterialsThermalconductivityEnum : return "MaterialsThermalconductivity";
-		case MaterialsTemperateiceconductivityEnum : return "MaterialsTemperateiceconductivity";
-		case MaterialsLithosphereShearModulusEnum : return "MaterialsLithosphereShearModulus";
-		case MaterialsLithosphereDensityEnum : return "MaterialsLithosphereDensity";
-		case MaterialsMantleShearModulusEnum : return "MaterialsMantleShearModulus";
-		case MaterialsMantleDensityEnum : return "MaterialsMantleDensity";
-		case MaterialsEarthDensityEnum : return "MaterialsEarthDensity";
-		case MeshAverageVertexConnectivityEnum : return "MeshAverageVertexConnectivity";
-		case MeshLatEnum : return "MeshLat";
-		case MeshLongEnum : return "MeshLong";
-		case MeshXEnum : return "MeshX";
-		case MeshYEnum : return "MeshY";
-		case MeshZEnum : return "MeshZ";
-		case MeshScaleFactorEnum : return "MeshScaleFactor";
-		case MeshElementsEnum : return "MeshElements";
-		case MeshNumberofelementsEnum : return "MeshNumberofelements";
-		case MeshNumberoflayersEnum : return "MeshNumberoflayers";
-		case MeshNumberofverticesEnum : return "MeshNumberofvertices";
-		case MeshVertexonbaseEnum : return "MeshVertexonbase";
-		case MeshVertexonsurfaceEnum : return "MeshVertexonsurface";
-		case MeshVertexonboundaryEnum : return "MeshVertexonboundary";
-		case MeshElementtypeEnum : return "MeshElementtype";
-		case DomainTypeEnum : return "DomainType";
-		case DomainDimensionEnum : return "DomainDimension";
-		case Domain2DhorizontalEnum : return "Domain2Dhorizontal";
-		case Domain2DverticalEnum : return "Domain2Dvertical";
-		case Domain3DEnum : return "Domain3D";
-		case Domain3DsurfaceEnum : return "Domain3Dsurface";
+		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 MasstransportSpcthicknessEnum : return "MasstransportSpcthickness";
+		case MasstransportRequestedOutputsEnum : return "MasstransportRequestedOutputs";
 		case MasstransportStabilizationEnum : return "MasstransportStabilization";
-		case MasstransportNumRequestedOutputsEnum : return "MasstransportNumRequestedOutputs";
-		case MasstransportRequestedOutputsEnum : return "MasstransportRequestedOutputs";
+		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 OutputBufferPointerEnum : return "OutputBufferPointer";
+		case OutputBufferSizePointerEnum : return "OutputBufferSizePointer";
+		case OutputdefinitionEnum : return "Outputdefinition";
+		case OutputFileNameEnum : return "OutputFileName";
+		case OutputFilePointerEnum : return "OutputFilePointer";
+		case ParamEnum : return "Param";
+		case ParametersEnum : return "Parameters";
+		case QmuErrNameEnum : return "QmuErrName";
+		case QmuInNameEnum : return "QmuInName";
 		case QmuIsdakotaEnum : return "QmuIsdakota";
-		case MassFluxSegmentsEnum : return "MassFluxSegments";
-		case MassFluxSegmentsPresentEnum : return "MassFluxSegmentsPresent";
 		case QmuNumberofpartitionsEnum : return "QmuNumberofpartitions";
-		case QmuNumberofresponsesEnum : return "QmuNumberofresponses";
+		case QmuOutNameEnum : return "QmuOutName";
 		case QmuPartitionEnum : return "QmuPartition";
 		case QmuResponsedescriptorsEnum : return "QmuResponsedescriptors";
-		case QmuVariabledescriptorsEnum : return "QmuVariabledescriptors";
-		case SettingsResultsOnNodesEnum : return "SettingsResultsOnNodes";
+		case RestartFileNameEnum : return "RestartFileName";
+		case ResultsEnum : return "Results";
+		case RootPathEnum : return "RootPath";
+		case SaveResultsEnum : return "SaveResults";
+		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 SealevelriseHElasticEnum : return "SealevelriseHElastic";
+		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 SealevelriseTidalLoveHEnum : return "SealevelriseTidalLoveH";
+		case SealevelriseTidalLoveKEnum : return "SealevelriseTidalLoveK";
+		case SealevelriseTransitionsEnum : return "SealevelriseTransitions";
+		case SealevelriseUElasticEnum : return "SealevelriseUElastic";
 		case SettingsIoGatherEnum : return "SettingsIoGather";
-		case SettingsLowmemEnum : return "SettingsLowmem";
 		case SettingsOutputFrequencyEnum : return "SettingsOutputFrequency";
 		case SettingsRecordingFrequencyEnum : return "SettingsRecordingFrequency";
+		case SettingsResultsOnNodesEnum : return "SettingsResultsOnNodes";
+		case SettingsSolverResidueThresholdEnum : return "SettingsSolverResidueThreshold";
 		case SettingsWaitonlockEnum : return "SettingsWaitonlock";
-		case SettingsSolverResidueThresholdEnum : return "SettingsSolverResidueThreshold";
-		case DebugProfilingEnum : return "DebugProfiling";
-		case ProfilingCurrentMemEnum : return "ProfilingCurrentMem";
-		case ProfilingCurrentFlopsEnum : return "ProfilingCurrentFlops";
-		case ProfilingSolutionTimeEnum : return "ProfilingSolutionTime";
+		case SmbAdThreshEnum : return "SmbAdThresh";
+		case SmbAIceEnum : return "SmbAIce";
+		case SmbAIdxEnum : return "SmbAIdx";
+		case SmbASnowEnum : return "SmbASnow";
+		case SmbCldFracEnum : return "SmbCldFrac";
+		case SmbDelta18oEnum : return "SmbDelta18o";
+		case SmbDelta18oSurfaceEnum : return "SmbDelta18oSurface";
+		case SmbDenIdxEnum : return "SmbDenIdx";
+		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 SmbIsd18opdEnum : return "SmbIsd18opd";
+		case SmbIsdelta18oEnum : return "SmbIsdelta18o";
+		case SmbIsdensificationEnum : return "SmbIsdensification";
+		case SmbIsgraingrowthEnum : return "SmbIsgraingrowth";
+		case SmbIsmeltEnum : return "SmbIsmelt";
+		case SmbIsmungsmEnum : return "SmbIsmungsm";
+		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 SmbRequestedOutputsEnum : return "SmbRequestedOutputs";
+		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 SurfaceEnum : return "Surface";
+		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 ThermalIsdynamicbasalspcEnum : return "ThermalIsdynamicbasalspc";
-		case ThermalReltolEnum : return "ThermalReltol";
 		case ThermalMaxiterEnum : return "ThermalMaxiter";
+		case ThermalNumRequestedOutputsEnum : return "ThermalNumRequestedOutputs";
 		case ThermalPenaltyFactorEnum : return "ThermalPenaltyFactor";
 		case ThermalPenaltyLockEnum : return "ThermalPenaltyLock";
 		case ThermalPenaltyThresholdEnum : return "ThermalPenaltyThreshold";
-		case ThermalSpctemperatureEnum : return "ThermalSpctemperature";
+		case ThermalReltolEnum : return "ThermalReltol";
+		case ThermalRequestedOutputsEnum : return "ThermalRequestedOutputs";
 		case ThermalStabilizationEnum : return "ThermalStabilization";
-		case ThermalNumRequestedOutputsEnum : return "ThermalNumRequestedOutputs";
-		case ThermalRequestedOutputsEnum : return "ThermalRequestedOutputs";
-		case GiaMantleViscosityEnum : return "GiaMantleViscosity";
-		case GiaLithosphereThicknessEnum : return "GiaLithosphereThickness";
-		case ThicknessEnum : return "Thickness";
+		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 TimesteppingFinalTimeEnum : return "TimesteppingFinalTime";
-		case TimesteppingCflCoefficientEnum : return "TimesteppingCflCoefficient";
-		case TimesteppingTimeAdaptEnum : return "TimesteppingTimeAdapt";
 		case TimesteppingTimeStepEnum : return "TimesteppingTimeStep";
-		case TimesteppingInterpForcingsEnum : return "TimesteppingInterpForcings";
-		case TimesteppingCouplingTimeEnum : return "TimesteppingCouplingTime";
-		case TransientIssmbEnum : return "TransientIssmb";
+		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 TransientIsoceancouplingEnum : return "TransientIsoceancoupling";
-		case TransientIsstressbalanceEnum : return "TransientIsstressbalance";
+		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 TransientIsthermalEnum : return "TransientIsthermal";
-		case TransientIsgiaEnum : return "TransientIsgia";
-		case TransientIsesaEnum : return "TransientIsesa";
-		case TransientIsdamageevolutionEnum : return "TransientIsdamageevolution";
-		case TransientIshydrologyEnum : return "TransientIshydrology";
 		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 BalancethicknessSpcthicknessEnum : return "BalancethicknessSpcthickness";
-		case BalancethicknessApparentMassbalanceEnum : return "BalancethicknessApparentMassbalance";
-		case BalancethicknessDiffusionCoefficientEnum : return "BalancethicknessDiffusionCoefficient";
+		case VelocityEnum : return "Velocity";
+		case ParametersENDEnum : return "ParametersEND";
+		case InputsSTARTEnum : return "InputsSTART";
+		case AdjointEnum : return "Adjoint";
+		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 BalancethicknessOmega0Enum : return "BalancethicknessOmega0";
-		case BalancethicknessD0Enum : return "BalancethicknessD0";
-		case SmbEnum : return "Smb";
-		case SmbAnalysisEnum : return "SmbAnalysis";
-		case SmbSolutionEnum : return "SmbSolution";
-		case SmbNumRequestedOutputsEnum : return "SmbNumRequestedOutputs";
-		case SmbRequestedOutputsEnum : return "SmbRequestedOutputs";
-		case SmbIsInitializedEnum : return "SmbIsInitialized";
+		case BalancethicknessThickeningRateEnum : return "BalancethicknessThickeningRate";
+		case BasalforcingsFloatingiceMeltingRateEnum : return "BasalforcingsFloatingiceMeltingRate";
+		case BasalforcingsGeothermalfluxEnum : return "BasalforcingsGeothermalflux";
+		case BasalforcingsGroundediceMeltingRateEnum : return "BasalforcingsGroundediceMeltingRate";
+		case BasalforcingsPicoBasinIdEnum : return "BasalforcingsPicoBasinId";
+		case BasalforcingsPicoBoxIdEnum : return "BasalforcingsPicoBoxId";
+		case BasalforcingsPicoMaxboxcountEnum : return "BasalforcingsPicoMaxboxcount";
+		case BaseEnum : return "Base";
+		case BedEnum : return "Bed";
+		case BedSlopeXEnum : return "BedSlopeX";
+		case BedSlopeYEnum : return "BedSlopeY";
+		case CalvingCalvingrateEnum : return "CalvingCalvingrate";
+		case CalvingHabFractionEnum : return "CalvingHabFraction";
+		case CalvinglevermannCoeffEnum : return "CalvinglevermannCoeff";
+		case CalvinglevermannMeltingrateEnum : return "CalvinglevermannMeltingrate";
+		case CalvingMeltingrateEnum : return "CalvingMeltingrate";
+		case CalvingratexAverageEnum : return "CalvingratexAverage";
+		case CalvingratexEnum : return "Calvingratex";
+		case CalvingrateyAverageEnum : return "CalvingrateyAverage";
+		case CalvingrateyEnum : return "Calvingratey";
+		case CalvingStressThresholdFloatingiceEnum : return "CalvingStressThresholdFloatingice";
+		case CalvingStressThresholdGroundediceEnum : return "CalvingStressThresholdGroundedice";
+		case ConvergedEnum : return "Converged";
+		case CrevasseDepthEnum : return "CrevasseDepth";
+		case DamageDbarEnum : return "DamageDbar";
+		case DamageDEnum : return "DamageD";
+		case DamageFEnum : return "DamageF";
+		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 EnthalpyEnum : return "Enthalpy";
+		case EnthalpyPicardEnum : return "EnthalpyPicard";
+		case EplHeadEnum : return "EplHead";
+		case EplHeadOldEnum : return "EplHeadOld";
+		case EplHeadSlopeXEnum : return "EplHeadSlopeX";
+		case EplHeadSlopeYEnum : return "EplHeadSlopeY";
+		case EsaDeltathicknessEnum : return "EsaDeltathickness";
+		case EsaXmotionEnum : return "EsaXmotion";
+		case EsaYmotionEnum : return "EsaYmotion";
+		case EtaDiffEnum : return "EtaDiff";
+		case FrictionAsEnum : return "FrictionAs";
+		case FrictionCEnum : return "FrictionC";
+		case FrictionCoefficientcoulombEnum : return "FrictionCoefficientcoulomb";
+		case FrictionCoefficientEnum : return "FrictionCoefficient";
+		case FrictionEffectivePressureEnum : return "FrictionEffectivePressure";
+		case FrictionMEnum : return "FrictionM";
+		case FrictionPEnum : return "FrictionP";
+		case FrictionPressureAdjustedTemperatureEnum : return "FrictionPressureAdjustedTemperature";
+		case FrictionQEnum : return "FrictionQ";
+		case FrictionWaterLayerEnum : return "FrictionWaterLayer";
+		case GeometryHydrostaticRatioEnum : return "GeometryHydrostaticRatio";
+		case GiaLithosphereThicknessEnum : return "GiaLithosphereThickness";
+		case GiaMantleViscosityEnum : return "GiaMantleViscosity";
+		case GradientEnum : return "Gradient";
+		case HydrologyBumpHeightEnum : return "HydrologyBumpHeight";
+		case HydrologyBumpSpacingEnum : return "HydrologyBumpSpacing";
+		case HydrologydcBasalMoulinInputEnum : return "HydrologydcBasalMoulinInput";
+		case HydrologydcEplThicknessEnum : return "HydrologydcEplThickness";
+		case HydrologydcEplThicknessOldEnum : return "HydrologydcEplThicknessOld";
+		case HydrologydcMaskEplactiveEltEnum : return "HydrologydcMaskEplactiveElt";
+		case HydrologydcMaskEplactiveNodeEnum : return "HydrologydcMaskEplactiveNode";
+		case HydrologydcSedimentTransmitivityEnum : return "HydrologydcSedimentTransmitivity";
+		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 HydrologyWaterVxEnum : return "HydrologyWaterVx";
+		case HydrologyWaterVyEnum : return "HydrologyWaterVy";
+		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 MasstransportSpcthicknessEnum : return "MasstransportSpcthickness";
+		case MaterialsRheologyBbarEnum : return "MaterialsRheologyBbar";
+		case MaterialsRheologyBEnum : return "MaterialsRheologyB";
+		case MaterialsRheologyEbarEnum : return "MaterialsRheologyEbar";
+		case MaterialsRheologyEcbarEnum : return "MaterialsRheologyEcbar";
+		case MaterialsRheologyEcEnum : return "MaterialsRheologyEc";
+		case MaterialsRheologyEEnum : return "MaterialsRheologyE";
+		case MaterialsRheologyEsbarEnum : return "MaterialsRheologyEsbar";
+		case MaterialsRheologyEsEnum : return "MaterialsRheologyEs";
+		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 NodeEnum : return "Node";
+		case OmegaAbsGradientEnum : return "OmegaAbsGradient";
+		case P0Enum : return "P0";
+		case P1Enum : return "P1";
+		case PressureEnum : return "Pressure";
+		case RheologyBAbsGradientEnum : return "RheologyBAbsGradient";
+		case RheologyBbarAbsGradientEnum : return "RheologyBbarAbsGradient";
+		case SealevelEnum : return "Sealevel";
+		case SealevelriseDeltathicknessEnum : return "SealevelriseDeltathickness";
+		case SedimentHeadEnum : return "SedimentHead";
+		case SedimentHeadOldEnum : return "SedimentHeadOld";
+		case SedimentHeadResidualEnum : return "SedimentHeadResidual";
+		case SigmaNNEnum : return "SigmaNN";
+		case SmbAccumulationEnum : return "SmbAccumulation";
+		case SmbAEnum : return "SmbA";
+		case SmbAiniEnum : return "SmbAini";
+		case SmbAValueEnum : return "SmbAValue";
+		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 SmbDiniEnum : return "SmbDini";
+		case SmbDlwrfEnum : return "SmbDlwrf";
+		case SmbDswrfEnum : return "SmbDswrf";
+		case SmbDzEnum : return "SmbDz";
 		case SmbDziniEnum : return "SmbDzini";
-		case SmbDiniEnum : return "SmbDini";
-		case SmbReiniEnum : return "SmbReini";
+		case SmbDzMinEnum : return "SmbDzMin";
+		case SmbDzTopEnum : return "SmbDzTop";
+		case SmbEAirEnum : return "SmbEAir";
+		case SmbECEnum : return "SmbEC";
+		case SmbECiniEnum : return "SmbECini";
+		case SmbElaEnum : return "SmbEla";
+		case SmbEvaporationEnum : return "SmbEvaporation";
+		case SmbGdnEnum : return "SmbGdn";
 		case SmbGdniniEnum : return "SmbGdnini";
+		case SmbGspEnum : return "SmbGsp";
 		case SmbGspiniEnum : return "SmbGspini";
-		case SmbECiniEnum : return "SmbECini";
-		case SmbWiniEnum : return "SmbWini";
-		case SmbAiniEnum : return "SmbAini";
-		case SmbTiniEnum : return "SmbTini";
+		case SmbHrefEnum : return "SmbHref";
+		case SmbIsInitializedEnum : return "SmbIsInitialized";
+		case SmbMassBalanceEnum : return "SmbMassBalance";
+		case SmbMeltEnum : return "SmbMelt";
+		case SmbMonthlytemperaturesEnum : return "SmbMonthlytemperatures";
+		case SmbPAirEnum : return "SmbPAir";
+		case SmbPddfacIceEnum : return "SmbPddfacIce";
+		case SmbPddfacSnowEnum : return "SmbPddfacSnow";
+		case SmbPEnum : return "SmbP";
+		case SmbPrecipitationEnum : return "SmbPrecipitation";
+		case SmbPrecipitationsLgmEnum : return "SmbPrecipitationsLgm";
+		case SmbPrecipitationsPresentdayEnum : return "SmbPrecipitationsPresentday";
+		case SmbReEnum : return "SmbRe";
+		case SmbRefreezeEnum : return "SmbRefreeze";
+		case SmbReiniEnum : return "SmbReini";
+		case SmbRunoffEnum : return "SmbRunoff";
+		case SmbS0pEnum : return "SmbS0p";
+		case SmbS0tEnum : return "SmbS0t";
 		case SmbSizeiniEnum : return "SmbSizeini";
-		case SMBforcingEnum : return "SMBforcing";
-		case SmbMassBalanceEnum : return "SmbMassBalance";
-		case SMBgembEnum : return "SMBgemb";
-		case SmbInitDensityScalingEnum : return "SmbInitDensityScaling";
-		case SmbThermoDeltaTScalingEnum : return "SmbThermoDeltaTScaling";
-		case SmbAdThreshEnum : return "SmbAdThresh";
+		case SmbSmbrefEnum : return "SmbSmbref";
 		case SmbTaEnum : return "SmbTa";
-		case SmbVEnum : return "SmbV";
-		case SmbDswrfEnum : return "SmbDswrf";
-		case SmbDlwrfEnum : return "SmbDlwrf";
-		case SmbPEnum : return "SmbP";
-		case SmbEAirEnum : return "SmbEAir";
-		case SmbPAirEnum : return "SmbPAir";
+		case SmbTemperaturesLgmEnum : return "SmbTemperaturesLgm";
+		case SmbTemperaturesPresentdayEnum : return "SmbTemperaturesPresentday";
+		case SmbTEnum : return "SmbT";
+		case SmbTeValueEnum : return "SmbTeValue";
+		case SmbTiniEnum : return "SmbTini";
 		case SmbTmeanEnum : return "SmbTmean";
-		case SmbCEnum : return "SmbC";
 		case SmbTzEnum : return "SmbTz";
+		case SmbVEnum : return "SmbV";
 		case SmbVzEnum : return "SmbVz";
-		case SmbDtEnum : return "SmbDt";
-		case SmbDzEnum : return "SmbDz";
-		case SmbAIdxEnum : return "SmbAIdx";
-		case SmbSwIdxEnum : return "SmbSwIdx";
-		case SmbDenIdxEnum : return "SmbDenIdx";
+		case SmbWEnum : return "SmbW";
+		case SmbWiniEnum : return "SmbWini";
+		case SmbZMaxEnum : return "SmbZMax";
+		case SmbZMinEnum : return "SmbZMin";
 		case SmbZTopEnum : return "SmbZTop";
-		case SmbDzTopEnum : return "SmbDzTop";
-		case SmbDzMinEnum : return "SmbDzMin";
 		case SmbZYEnum : return "SmbZY";
-		case SmbZMaxEnum : return "SmbZMax";
-		case SmbZMinEnum : return "SmbZMin";
-		case SmbOutputFreqEnum : return "SmbOutputFreq";
-		case SmbASnowEnum : return "SmbASnow";
-		case SmbAIceEnum : return "SmbAIce";
-		case SmbCldFracEnum : return "SmbCldFrac";
-		case SmbT0wetEnum : return "SmbT0wet";
-		case SmbT0dryEnum : return "SmbT0dry";
-		case SmbKEnum : return "SmbK";
-		case SmbDEnum : return "SmbD";
-		case SmbReEnum : return "SmbRe";
-		case SmbGdnEnum : return "SmbGdn";
-		case SmbGspEnum : return "SmbGsp";
-		case SmbECEnum : return "SmbEC";
-		case SmbWEnum : return "SmbW";
-		case SmbAEnum : return "SmbA";
-		case SmbTEnum : return "SmbT";
-		case SmbAValueEnum : return "SmbAValue";
-		case SmbTeValueEnum : return "SmbTeValue";
-		case SmbIsgraingrowthEnum : return "SmbIsgraingrowth";
-		case SmbIsalbedoEnum : return "SmbIsalbedo";
-		case SmbIsshortwaveEnum : return "SmbIsshortwave";
-		case SmbIsthermalEnum : return "SmbIsthermal";
-		case SmbIsaccumulationEnum : return "SmbIsaccumulation";
-		case SmbIsmeltEnum : return "SmbIsmelt";
-		case SmbIsdensificationEnum : return "SmbIsdensification";
-		case SmbIsturbulentfluxEnum : return "SmbIsturbulentflux";
-		case SmbDzAddEnum : return "SmbDzAdd";
-		case SmbMAddEnum : return "SmbMAdd";
-		case SmbFACEnum : return "SmbFAC";
-		case SMBpddEnum : return "SMBpdd";
-		case SmbDelta18oEnum : return "SmbDelta18o";
-		case SmbDelta18oSurfaceEnum : return "SmbDelta18oSurface";
-		case SmbIsdelta18oEnum : return "SmbIsdelta18o";
-		case SmbIssetpddfacEnum : return "SmbIssetpddfac";
-		case SmbIsmungsmEnum : return "SmbIsmungsm";
-		case SmbIsd18opdEnum : return "SmbIsd18opd";
-		case SmbIstemperaturescaledEnum : return "SmbIstemperaturescaled";
-		case SmbPrecipitationsPresentdayEnum : return "SmbPrecipitationsPresentday";
-		case SmbPrecipitationsLgmEnum : return "SmbPrecipitationsLgm";
-		case SmbTemperaturesPresentdayEnum : return "SmbTemperaturesPresentday";
-		case SmbTemperaturesLgmEnum : return "SmbTemperaturesLgm";
-		case SmbPrecipitationEnum : return "SmbPrecipitation";
-		case SmbPddfacSnowEnum : return "SmbPddfacSnow";
-		case SmbPddfacIceEnum : return "SmbPddfacIce";
-		case SmbDesfacEnum : return "SmbDesfac";
-		case SmbS0pEnum : return "SmbS0p";
-		case SmbS0tEnum : return "SmbS0t";
-		case SmbRlapsEnum : return "SmbRlaps";
-		case SmbRlapslgmEnum : return "SmbRlapslgm";
-		case SmbPfacEnum : return "SmbPfac";
-		case SmbTdiffEnum : return "SmbTdiff";
-		case SmbSealevEnum : return "SmbSealev";
-		case SMBd18opddEnum : return "SMBd18opdd";
-		case SmbDpermilEnum : return "SmbDpermil";
-		case SmbFEnum : return "SmbF";
-		case SMBgradientsEnum : return "SMBgradients";
-		case SmbMonthlytemperaturesEnum : return "SmbMonthlytemperatures";
-		case SmbHrefEnum : return "SmbHref";
-		case SmbSmbrefEnum : return "SmbSmbref";
-		case SmbBPosEnum : return "SmbBPos";
-		case SmbBNegEnum : return "SmbBNeg";
-		case SMBhenningEnum : return "SMBhenning";
-		case SMBcomponentsEnum : return "SMBcomponents";
-		case SmbAccumulationEnum : return "SmbAccumulation";
-		case SmbEvaporationEnum : return "SmbEvaporation";
-		case SmbRunoffEnum : return "SmbRunoff";
-		case SMBmeltcomponentsEnum : return "SMBmeltcomponents";
-		case SmbMeltEnum : return "SmbMelt";
-		case SmbRefreezeEnum : return "SmbRefreeze";
-		case SMBgcmEnum : return "SMBgcm";
-		case SMBgradientselaEnum : return "SMBgradientsela";
-		case SmbElaEnum : return "SmbEla";
-		case SmbBMaxEnum : return "SmbBMax";
-		case SmbBMinEnum : return "SmbBMin";
-		case AdjointpEnum : return "Adjointp";
-		case AdjointxEnum : return "Adjointx";
-		case AdjointyEnum : return "Adjointy";
-		case AdjointzEnum : return "Adjointz";
-		case BalancethicknessMisfitEnum : return "BalancethicknessMisfit";
-		case BedSlopeXEnum : return "BedSlopeX";
-		case BedSlopeYEnum : return "BedSlopeY";
-		case BoundaryEnum : return "Boundary";
-		case ConvergedEnum : return "Converged";
-		case InternalEnum : return "Internal";
-		case MassFluxEnum : return "MassFlux";
-		case MeltingOffsetEnum : return "MeltingOffset";
-		case MisfitEnum : return "Misfit";
-		case PressureEnum : return "Pressure";
-		case AndroidFrictionCoefficientEnum : return "AndroidFrictionCoefficient";
-		case ResetPenaltiesEnum : return "ResetPenalties";
+		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 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 TemperaturePicardEnum : return "TemperaturePicard";
-		case TemperaturePDDEnum : return "TemperaturePDD";
+		case ThicknessAbsGradientEnum : return "ThicknessAbsGradient";
 		case ThicknessAbsMisfitEnum : return "ThicknessAbsMisfit";
-		case SurfaceAbsMisfitEnum : return "SurfaceAbsMisfit";
-		case OmegaAbsGradientEnum : return "OmegaAbsGradient";
-		case EtaDiffEnum : return "EtaDiff";
-		case EtaAbsGradientEnum : return "EtaAbsGradient";
+		case ThicknessAcrossGradientEnum : return "ThicknessAcrossGradient";
+		case ThicknessAlongGradientEnum : return "ThicknessAlongGradient";
+		case ThicknessEnum : return "Thickness";
+		case ThicknessPositiveEnum : return "ThicknessPositive";
 		case VelEnum : return "Vel";
-		case VelocityEnum : return "Velocity";
 		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 VzSSAEnum : return "VzSSA";
+		case VzFSEnum : return "VzFS";
 		case VzHOEnum : return "VzHO";
-		case VzFSEnum : return "VzFS";
-		case VxMeshEnum : return "VxMesh";
-		case VyMeshEnum : return "VyMesh";
 		case VzMeshEnum : return "VzMesh";
-		case EnthalpyEnum : return "Enthalpy";
-		case EnthalpyPicardEnum : return "EnthalpyPicard";
-		case ThicknessAbsGradientEnum : return "ThicknessAbsGradient";
-		case ThicknessAlongGradientEnum : return "ThicknessAlongGradient";
-		case ThicknessAcrossGradientEnum : return "ThicknessAcrossGradient";
-		case ThicknessPositiveEnum : return "ThicknessPositive";
-		case IntMatParamEnum : return "IntMatParam";
-		case RheologyBbarAbsGradientEnum : return "RheologyBbarAbsGradient";
-		case RheologyBAbsGradientEnum : return "RheologyBAbsGradient";
-		case DragCoefficientAbsGradientEnum : return "DragCoefficientAbsGradient";
-		case TransientInputEnum : return "TransientInput";
-		case WaterfractionEnum : return "Waterfraction";
+		case VzSSAEnum : return "VzSSA";
+		case WatercolumnEnum : return "Watercolumn";
+		case WaterColumnOldEnum : return "WaterColumnOld";
 		case WaterfractionDrainageEnum : return "WaterfractionDrainage";
 		case WaterfractionDrainageIntegratedEnum : return "WaterfractionDrainageIntegrated";
-		case WatercolumnEnum : return "Watercolumn";
-		case ViscousHeatingEnum : return "ViscousHeating";
-		case HydrologyWaterVxEnum : return "HydrologyWaterVx";
-		case HydrologyWaterVyEnum : return "HydrologyWaterVy";
-		case DrivingStressXEnum : return "DrivingStressX";
-		case DrivingStressYEnum : return "DrivingStressY";
-		case SigmaNNEnum : return "SigmaNN";
-		case StressTensorEnum : return "StressTensor";
-		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 StressMaxPrincipalEnum : return "StressMaxPrincipal";
-		case DeviatoricStressEnum : return "DeviatoricStress";
-		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 WaterfractionEnum : return "Waterfraction";
+		case WaterheightEnum : return "Waterheight";
+		case WeightsSurfaceObservationEnum : return "WeightsSurfaceObservation";
+		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 AdjointpEnum : return "Adjointp";
+		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 AutodiffKeepEnum : return "AutodiffKeep";
+		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 BasalCrevasseEnum : return "BasalCrevasse";
+		case BasalforcingsPicoEnum : return "BasalforcingsPico";
+		case BasalforcingsPicoFarOceantemperatureEnum : return "BasalforcingsPicoFarOceantemperature";
+		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 CfsurfacelogvelEnum : return "Cfsurfacelogvel";
+		case CfsurfacesquareEnum : return "Cfsurfacesquare";
+		case ClosedEnum : return "Closed";
+		case ColinearEnum : return "Colinear";
+		case ConstantsGEnum : return "ConstantsG";
+		case ConstantsReferencetemperatureEnum : return "ConstantsReferencetemperature";
+		case ConstraintsEnum : return "Constraints";
+		case ContactEnum : return "Contact";
+		case ContourEnum : return "Contour";
+		case ContoursEnum : return "Contours";
+		case ControlInputEnum : return "ControlInput";
+		case ControlSteadyEnum : return "ControlSteady";
+		case CrouzeixRaviartEnum : return "CrouzeixRaviart";
+		case CuffeyEnum : return "Cuffey";
+		case CuffeyTemperateEnum : return "CuffeyTemperate";
+		case DamageC4Enum : return "DamageC4";
+		case DamageElementinterpEnum : return "DamageElementinterp";
+		case DamageEvolutionAnalysisEnum : return "DamageEvolutionAnalysis";
+		case DamageEvolutionSolutionEnum : return "DamageEvolutionSolution";
+		case DamageMaxiterEnum : return "DamageMaxiter";
+		case DataSetEnum : return "DataSet";
+		case DatasetInputEnum : return "DatasetInput";
+		case DataSetParamEnum : return "DataSetParam";
+		case DefaultAnalysisEnum : return "DefaultAnalysis";
+		case DefaultCalvingEnum : return "DefaultCalving";
+		case DegreeOfChannelizationEnum : return "DegreeOfChannelization";
+		case DenseEnum : return "Dense";
+		case DependentObjectEnum : return "DependentObject";
+		case DepthAverageAnalysisEnum : return "DepthAverageAnalysis";
 		case DeviatoricStresseffectiveEnum : return "DeviatoricStresseffective";
-		case LambdaSEnum : return "LambdaS";
-		case StrainRateEnum : return "StrainRate";
-		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 DeviatoricStressErrorEstimatorEnum : return "DeviatoricStressErrorEstimator";
 		case DivergenceEnum : return "Divergence";
-		case MaxDivergenceEnum : return "MaxDivergence";
-		case GiaCrossSectionShapeEnum : return "GiaCrossSectionShape";
+		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 EffectivePressureStackedEnum : return "EffectivePressureStacked";
+		case EffectivePressureTimeAverageEnum : return "EffectivePressureTimeAverage";
+		case ElementEnum : return "Element";
+		case ElementHookEnum : return "ElementHook";
+		case ElementSIdEnum : return "ElementSId";
+		case EnthalpyAnalysisEnum : return "EnthalpyAnalysis";
+		case EplHeadStackedEnum : return "EplHeadStacked";
+		case EplHeadTimeAverageEnum : return "EplHeadTimeAverage";
+		case EsaAnalysisEnum : return "EsaAnalysis";
+		case EsaEmotionEnum : return "EsaEmotion";
+		case EsaNmotionEnum : return "EsaNmotion";
+		case EsaNumRequestedOutputsEnum : return "EsaNumRequestedOutputs";
+		case EsaRotationrateEnum : return "EsaRotationrate";
+		case EsaSolutionEnum : return "EsaSolution";
+		case EsaStrainratexxEnum : return "EsaStrainratexx";
+		case EsaStrainratexyEnum : return "EsaStrainratexy";
+		case EsaStrainrateyyEnum : return "EsaStrainrateyy";
+		case EsaTransitionsEnum : return "EsaTransitions";
+		case EsaUmotionEnum : return "EsaUmotion";
+		case ExternalResultEnum : return "ExternalResult";
+		case ExtrapolationAnalysisEnum : return "ExtrapolationAnalysis";
+		case ExtrudeFromBaseAnalysisEnum : return "ExtrudeFromBaseAnalysis";
+		case ExtrudeFromTopAnalysisEnum : return "ExtrudeFromTopAnalysis";
+		case FemModelCommEnum : return "FemModelComm";
+		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 FlowequationBorderFSEnum : return "FlowequationBorderFS";
+		case FreeEnum : return "Free";
+		case FreeSurfaceBaseAnalysisEnum : return "FreeSurfaceBaseAnalysis";
+		case FreeSurfaceTopAnalysisEnum : return "FreeSurfaceTopAnalysis";
+		case FSApproximationEnum : return "FSApproximation";
+		case FsetEnum : return "Fset";
+		case FSpressureEnum : return "FSpressure";
+		case FSSolverEnum : return "FSSolver";
+		case FSvelocityEnum : return "FSvelocity";
+		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 GiadWdtEnum : return "GiadWdt";
+		case GiaIvinsAnalysisEnum : return "GiaIvinsAnalysis";
+		case GiaSolutionEnum : return "GiaSolution";
 		case GiaWEnum : return "GiaW";
-		case SaveResultsEnum : return "SaveResults";
-		case BoolExternalResultEnum : return "BoolExternalResult";
-		case DoubleExternalResultEnum : return "DoubleExternalResult";
-		case DoubleMatExternalResultEnum : return "DoubleMatExternalResult";
+		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 GsetEnum : return "Gset";
+		case GslEnum : return "Gsl";
+		case HOApproximationEnum : return "HOApproximation";
+		case HOFSApproximationEnum : return "HOFSApproximation";
+		case HookEnum : return "Hook";
+		case HydrologyBasalFluxEnum : return "HydrologyBasalFlux";
+		case HydrologyDCEfficientAnalysisEnum : return "HydrologyDCEfficientAnalysis";
+		case HydrologydcEnum : return "Hydrologydc";
+		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 HydrologydcEplThicknessStackedEnum : return "HydrologydcEplThicknessStacked";
+		case HydrologydcEplThicknessTimeAverageEnum : return "HydrologydcEplThicknessTimeAverage";
+		case HydrologyDCInefficientAnalysisEnum : return "HydrologyDCInefficientAnalysis";
+		case HydrologydcSedimentCompressibilityEnum : return "HydrologydcSedimentCompressibility";
+		case HydrologydcSedimentPorosityEnum : return "HydrologydcSedimentPorosity";
+		case HydrologydcSedimentThicknessEnum : return "HydrologydcSedimentThickness";
+		case HydrologydcWaterCompressibilityEnum : return "HydrologydcWaterCompressibility";
+		case HydrologyShreveAnalysisEnum : return "HydrologyShreveAnalysis";
+		case HydrologyshreveEnum : return "Hydrologyshreve";
+		case HydrologySolutionEnum : return "HydrologySolution";
+		case HydrologySommersAnalysisEnum : return "HydrologySommersAnalysis";
+		case HydrologysommersEnum : return "Hydrologysommers";
+		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 IncrementalEnum : return "Incremental";
+		case IndexedEnum : return "Indexed";
+		case InternalEnum : return "Internal";
+		case IntersectEnum : return "Intersect";
 		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 InversionCostFunctionThresholdEnum : return "InversionCostFunctionThreshold";
+		case InversionFatolEnum : return "InversionFatol";
+		case InversionFrtolEnum : return "InversionFrtol";
+		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 LambdaSEnum : return "LambdaS";
+		case LATaylorHoodEnum : return "LATaylorHood";
+		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 MantlePlumeGeothermalFluxEnum : return "MantlePlumeGeothermalFlux";
+		case MaskLandLevelsetEnum : return "MaskLandLevelset";
+		case MaskOceanLevelsetEnum : return "MaskOceanLevelset";
+		case MassconaxpbyEnum : return "Massconaxpby";
+		case MassconEnum : return "Masscon";
+		case MassfluxatgateEnum : return "Massfluxatgate";
+		case MassFluxEnum : return "MassFlux";
+		case MasstransportAnalysisEnum : return "MasstransportAnalysis";
+		case MasstransportSolutionEnum : return "MasstransportSolution";
+		case MatdamageiceEnum : return "Matdamageice";
+		case MatenhancediceEnum : return "Matenhancedice";
+		case MaterialsBetaEnum : return "MaterialsBeta";
+		case MaterialsEarthDensityEnum : return "MaterialsEarthDensity";
+		case MaterialsEnum : return "Materials";
+		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 MaterialsThermalconductivityEnum : return "MaterialsThermalconductivity";
+		case MaterialsThermalExchangeVelocityEnum : return "MaterialsThermalExchangeVelocity";
+		case MatestarEnum : return "Matestar";
+		case MaticeEnum : return "Matice";
+		case MatlithoEnum : return "Matlitho";
+		case MatparEnum : return "Matpar";
+		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 MeshLatEnum : return "MeshLat";
+		case MeshLongEnum : return "MeshLong";
+		case MeshNumberofelementsEnum : return "MeshNumberofelements";
+		case MeshXEnum : return "MeshX";
+		case MeshYEnum : return "MeshY";
+		case MINIcondensedEnum : return "MINIcondensed";
+		case MINIEnum : return "MINI";
+		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 NewDamageEnum : return "NewDamage";
+		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 Outputdefinition100Enum : return "Outputdefinition100";
+		case Outputdefinition1Enum : return "Outputdefinition1";
+		case P0ArrayEnum : return "P0Array";
+		case P1bubblecondensedEnum : return "P1bubblecondensed";
+		case P1bubbleEnum : return "P1bubble";
+		case P1DGEnum : return "P1DG";
+		case P1P1Enum : return "P1P1";
+		case P1P1GLSEnum : return "P1P1GLS";
+		case P1xP2Enum : return "P1xP2";
+		case P1xP3Enum : return "P1xP3";
+		case P1xP4Enum : return "P1xP4";
+		case P2bubblecondensedEnum : return "P2bubblecondensed";
+		case P2bubbleEnum : return "P2bubble";
+		case P2Enum : return "P2";
+		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 QmuNumberofresponsesEnum : return "QmuNumberofresponses";
+		case QmuVariabledescriptorsEnum : return "QmuVariabledescriptors";
+		case RegionaloutputEnum : return "Regionaloutput";
+		case RegularEnum : return "Regular";
+		case ResetPenaltiesEnum : return "ResetPenalties";
+		case RiftfrontEnum : return "Riftfront";
+		case ScaledEnum : return "Scaled";
+		case SealevelAbsoluteEnum : return "SealevelAbsolute";
+		case SealevelEmotionEnum : return "SealevelEmotion";
+		case SealevelEustaticEnum : return "SealevelEustatic";
+		case SealevelInertiaTensorXZEnum : return "SealevelInertiaTensorXZ";
+		case SealevelInertiaTensorYZEnum : return "SealevelInertiaTensorYZ";
+		case SealevelInertiaTensorZZEnum : return "SealevelInertiaTensorZZ";
+		case SealevelNmotionEnum : return "SealevelNmotion";
+		case SealevelriseAnalysisEnum : return "SealevelriseAnalysis";
+		case SealevelriseNumRequestedOutputsEnum : return "SealevelriseNumRequestedOutputs";
+		case SealevelriseSolutionEnum : return "SealevelriseSolution";
+		case SealevelriseStericRateEnum : return "SealevelriseStericRate";
+		case SealevelUmotionEnum : return "SealevelUmotion";
+		case SedimentHeadStackedEnum : return "SedimentHeadStacked";
+		case SedimentHeadTimeAverageEnum : return "SedimentHeadTimeAverage";
+		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 SettingsLowmemEnum : return "SettingsLowmem";
+		case SIAApproximationEnum : return "SIAApproximation";
+		case SigmaVMEnum : return "SigmaVM";
+		case SmbAnalysisEnum : return "SmbAnalysis";
+		case SMBcomponentsEnum : return "SMBcomponents";
+		case SMBd18opddEnum : return "SMBd18opdd";
+		case SmbDesfacEnum : return "SmbDesfac";
+		case SmbDpermilEnum : return "SmbDpermil";
+		case SmbDzAddEnum : return "SmbDzAdd";
+		case SmbFACEnum : return "SmbFAC";
+		case SMBforcingEnum : return "SMBforcing";
+		case SMBgcmEnum : return "SMBgcm";
+		case SMBgembEnum : return "SMBgemb";
+		case SMBgradientselaEnum : return "SMBgradientsela";
+		case SMBgradientsEnum : return "SMBgradients";
+		case SMBhenningEnum : return "SMBhenning";
+		case SmbMAddEnum : return "SmbMAdd";
+		case SMBmeltcomponentsEnum : return "SMBmeltcomponents";
+		case SmbOutputFreqEnum : return "SmbOutputFreq";
+		case SMBpddEnum : return "SMBpdd";
+		case SmbRlapsEnum : return "SmbRlaps";
+		case SmbRlapslgmEnum : return "SmbRlapslgm";
+		case SmbSolutionEnum : return "SmbSolution";
+		case SmoothAnalysisEnum : return "SmoothAnalysis";
+		case SoftMigrationEnum : return "SoftMigration";
+		case SpcDynamicEnum : return "SpcDynamic";
+		case SpcStaticEnum : return "SpcStatic";
+		case SpcTransientEnum : return "SpcTransient";
+		case SSAApproximationEnum : return "SSAApproximation";
+		case SSAFSApproximationEnum : return "SSAFSApproximation";
+		case SSAHOApproximationEnum : return "SSAHOApproximation";
+		case SsetEnum : return "Sset";
+		case SteadystateSolutionEnum : return "SteadystateSolution";
+		case StressbalanceAnalysisEnum : return "StressbalanceAnalysis";
+		case StressbalanceConvergenceNumStepsEnum : return "StressbalanceConvergenceNumSteps";
+		case StressbalanceSIAAnalysisEnum : return "StressbalanceSIAAnalysis";
+		case StressbalanceSolutionEnum : return "StressbalanceSolution";
+		case StressbalanceVerticalAnalysisEnum : return "StressbalanceVerticalAnalysis";
+		case StressIntensityFactorEnum : return "StressIntensityFactor";
+		case StringArrayParamEnum : return "StringArrayParam";
 		case StringExternalResultEnum : return "StringExternalResult";
-		case StepEnum : return "Step";
-		case TimeEnum : return "Time";
-		case WaterColumnOldEnum : return "WaterColumnOld";
-		case SurfaceObservationEnum : return "SurfaceObservation";
-		case WeightsSurfaceObservationEnum : return "WeightsSurfaceObservation";
-		case OutputdefinitionEnum : return "Outputdefinition";
-		case Outputdefinition1Enum : return "Outputdefinition1";
-		case Outputdefinition2Enum : return "Outputdefinition2";
-		case Outputdefinition3Enum : return "Outputdefinition3";
-		case Outputdefinition4Enum : return "Outputdefinition4";
-		case Outputdefinition5Enum : return "Outputdefinition5";
-		case Outputdefinition6Enum : return "Outputdefinition6";
-		case Outputdefinition7Enum : return "Outputdefinition7";
-		case Outputdefinition8Enum : return "Outputdefinition8";
-		case Outputdefinition9Enum : return "Outputdefinition9";
+		case StringParamEnum : return "StringParam";
+		case SubelementMigration2Enum : return "SubelementMigration2";
+		case SubelementMigration3Enum : return "SubelementMigration3";
+		case SubelementMigrationEnum : return "SubelementMigration";
+		case SurfaceCrevasseEnum : return "SurfaceCrevasse";
+		case SurfaceSlopeSolutionEnum : return "SurfaceSlopeSolution";
+		case TaylorHoodEnum : return "TaylorHood";
+		case TemperaturePDDEnum : return "TemperaturePDD";
+		case TetraEnum : return "Tetra";
+		case TetraInputEnum : return "TetraInput";
+		case ThermalAnalysisEnum : return "ThermalAnalysis";
+		case ThermalSolutionEnum : return "ThermalSolution";
+		case ThermalSpctemperatureEnum : return "ThermalSpctemperature";
+		case ThicknessErrorEstimatorEnum : return "ThicknessErrorEstimator";
+		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 VertexPIdEnum : return "VertexPId";
+		case VertexSIdEnum : return "VertexSId";
+		case VerticesEnum : return "Vertices";
+		case ViscousHeatingEnum : return "ViscousHeating";
+		case WaterEnum : return "Water";
+		case WorldCommEnum : return "WorldComm";
+		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 Outputdefinition10Enum : return "Outputdefinition10";
 		case Outputdefinition11Enum : return "Outputdefinition11";
 		case Outputdefinition12Enum : return "Outputdefinition12";
@@ -672,6 +1035,7 @@
 		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";
@@ -682,6 +1046,7 @@
 		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";
@@ -692,6 +1057,7 @@
 		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";
@@ -702,6 +1068,7 @@
 		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";
@@ -712,6 +1079,7 @@
 		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";
@@ -722,6 +1090,7 @@
 		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";
@@ -732,6 +1101,7 @@
 		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";
@@ -742,386 +1112,16 @@
 		case Outputdefinition97Enum : return "Outputdefinition97";
 		case Outputdefinition98Enum : return "Outputdefinition98";
 		case Outputdefinition99Enum : return "Outputdefinition99";
-		case Outputdefinition100Enum : return "Outputdefinition100";
+		case Outputdefinition9Enum : return "Outputdefinition9";
 		case OutputdefinitionListEnum : return "OutputdefinitionList";
-		case MassfluxatgateEnum : return "Massfluxatgate";
-		case NodalvalueEnum : return "Nodalvalue";
-		case RegionaloutputEnum : return "Regionaloutput";
-		case VxObsEnum : return "VxObs";
-		case VyObsEnum : return "VyObs";
-		case NumberedcostfunctionEnum : return "Numberedcostfunction";
-		case CfsurfacesquareEnum : return "Cfsurfacesquare";
-		case CfsurfacelogvelEnum : return "Cfsurfacelogvel";
-		case AbsoluteEnum : return "Absolute";
-		case IncrementalEnum : return "Incremental";
-		case AugmentedLagrangianREnum : return "AugmentedLagrangianR";
-		case AugmentedLagrangianRhopEnum : return "AugmentedLagrangianRhop";
-		case AugmentedLagrangianRlambdaEnum : return "AugmentedLagrangianRlambda";
-		case AugmentedLagrangianRholambdaEnum : return "AugmentedLagrangianRholambda";
-		case AugmentedLagrangianThetaEnum : return "AugmentedLagrangianTheta";
-		case NoneEnum : return "None";
-		case AggressiveMigrationEnum : return "AggressiveMigration";
-		case SoftMigrationEnum : return "SoftMigration";
-		case SubelementMigrationEnum : return "SubelementMigration";
-		case SubelementMigration2Enum : return "SubelementMigration2";
-		case SubelementMigration3Enum : return "SubelementMigration3";
-		case SubelementMigration4Enum : return "SubelementMigration4";
-		case ContactEnum : return "Contact";
-		case GroundingOnlyEnum : return "GroundingOnly";
-		case MaskGroundediceLevelsetEnum : return "MaskGroundediceLevelset";
-		case AdjointEnum : return "Adjoint";
-		case ColinearEnum : return "Colinear";
-		case ControlSteadyEnum : return "ControlSteady";
-		case FsetEnum : return "Fset";
-		case Gradient1Enum : return "Gradient1";
-		case Gradient2Enum : return "Gradient2";
-		case Gradient3Enum : return "Gradient3";
-		case GradientEnum : return "Gradient";
-		case GroundinglineMigrationEnum : return "GroundinglineMigration";
-		case GsetEnum : return "Gset";
-		case IndexEnum : return "Index";
-		case IndexedEnum : return "Indexed";
-		case IntersectEnum : return "Intersect";
-		case NodalEnum : return "Nodal";
-		case OldGradientEnum : return "OldGradient";
-		case OutputBufferPointerEnum : return "OutputBufferPointer";
-		case OutputBufferSizePointerEnum : return "OutputBufferSizePointer";
-		case OutputFilePointerEnum : return "OutputFilePointer";
-		case ToolkitsFileNameEnum : return "ToolkitsFileName";
-		case RootPathEnum : return "RootPath";
-		case OutputFileNameEnum : return "OutputFileName";
-		case InputFileNameEnum : return "InputFileName";
-		case LockFileNameEnum : return "LockFileName";
-		case RestartFileNameEnum : return "RestartFileName";
-		case ToolkitsTypesEnum : return "ToolkitsTypes";
-		case ToolkitsOptionsAnalysesEnum : return "ToolkitsOptionsAnalyses";
-		case ToolkitsOptionsStringsEnum : return "ToolkitsOptionsStrings";
-		case QmuErrNameEnum : return "QmuErrName";
-		case QmuInNameEnum : return "QmuInName";
-		case QmuOutNameEnum : return "QmuOutName";
-		case RegularEnum : return "Regular";
-		case ScaledEnum : return "Scaled";
-		case SeparateEnum : return "Separate";
-		case SsetEnum : return "Sset";
-		case DenseEnum : return "Dense";
-		case MpiDenseEnum : return "MpiDense";
-		case MpiSparseEnum : return "MpiSparse";
-		case SeqEnum : return "Seq";
-		case MpiEnum : return "Mpi";
-		case MumpsEnum : return "Mumps";
-		case GslEnum : return "Gsl";
-		case CuffeyEnum : return "Cuffey";
-		case BuddJackaEnum : return "BuddJacka";
-		case CuffeyTemperateEnum : return "CuffeyTemperate";
-		case PatersonEnum : return "Paterson";
-		case ArrheniusEnum : return "Arrhenius";
-		case LliboutryDuvalEnum : return "LliboutryDuval";
-		case ExtrapolationVariableEnum : return "ExtrapolationVariable";
-		case IceMaskNodeActivationEnum : return "IceMaskNodeActivation";
-		case LevelsetfunctionSlopeXEnum : return "LevelsetfunctionSlopeX";
-		case LevelsetfunctionSlopeYEnum : return "LevelsetfunctionSlopeY";
-		case LevelsetfunctionPicardEnum : return "LevelsetfunctionPicard";
-		case LevelsetReinitFrequencyEnum : return "LevelsetReinitFrequency";
-		case SealevelEnum : return "Sealevel";
-		case SealevelUmotionEnum : return "SealevelUmotion";
-		case SealevelNmotionEnum : return "SealevelNmotion";
-		case SealevelEmotionEnum : return "SealevelEmotion";
-		case SealevelAbsoluteEnum : return "SealevelAbsolute";
-		case SealevelEustaticEnum : return "SealevelEustatic";
-		case SealevelInertiaTensorXZEnum : return "SealevelInertiaTensorXZ";
-		case SealevelInertiaTensorYZEnum : return "SealevelInertiaTensorYZ";
-		case SealevelInertiaTensorZZEnum : return "SealevelInertiaTensorZZ";
 		case SealevelObsEnum : return "SealevelObs";
 		case SealevelWeightsEnum : return "SealevelWeights";
-		case SealevelriseDeltathicknessEnum : return "SealevelriseDeltathickness";
-		case SealevelriseMaxiterEnum : return "SealevelriseMaxiter";
-		case SealevelriseReltolEnum : return "SealevelriseReltol";
-		case SealevelriseAbstolEnum : return "SealevelriseAbstol";
-		case SealevelriseRigidEnum : return "SealevelriseRigid";
-		case SealevelriseElasticEnum : return "SealevelriseElastic";
-		case SealevelriseRotationEnum : return "SealevelriseRotation";
-		case SealevelriseTidalLoveHEnum : return "SealevelriseTidalLoveH";
-		case SealevelriseTidalLoveKEnum : return "SealevelriseTidalLoveK";
-		case SealevelriseFluidLoveEnum : return "SealevelriseFluidLove";
-		case SealevelriseEquatorialMoiEnum : return "SealevelriseEquatorialMoi";
-		case SealevelrisePolarMoiEnum : return "SealevelrisePolarMoi";
-		case SealevelriseAngularVelocityEnum : return "SealevelriseAngularVelocity";
-		case SealevelriseOceanAreaScalingEnum : return "SealevelriseOceanAreaScaling";
-		case SealevelriseStericRateEnum : return "SealevelriseStericRate";
-		case SealevelriseGElasticEnum : return "SealevelriseGElastic";
-		case SealevelriseUElasticEnum : return "SealevelriseUElastic";
-		case SealevelriseHElasticEnum : return "SealevelriseHElastic";
-		case SealevelriseTransitionsEnum : return "SealevelriseTransitions";
-		case SealevelriseRequestedOutputsEnum : return "SealevelriseRequestedOutputs";
-		case SealevelriseNumRequestedOutputsEnum : return "SealevelriseNumRequestedOutputs";
-		case LoveNfreqEnum : return "LoveNfreq";
-		case LoveFrequenciesEnum : return "LoveFrequencies";
-		case LoveShNmaxEnum : return "LoveShNmax";
-		case LoveShNminEnum : return "LoveShNmin";
-		case LoveG0Enum : return "LoveG0";
-		case LoveR0Enum : return "LoveR0";
-		case LoveMu0Enum : return "LoveMu0";
-		case LoveAllowLayerDeletionEnum : return "LoveAllowLayerDeletion";
-		case LoveForcingTypeEnum : return "LoveForcingType";
-		case LoveHrEnum : return "LoveHr";
-		case LoveKrEnum : return "LoveKr";
-		case LoveLrEnum : return "LoveLr";
-		case LoveHiEnum : return "LoveHi";
-		case LoveKiEnum : return "LoveKi";
-		case LoveLiEnum : return "LoveLi";
-		case LoveKernelsEnum : return "LoveKernels";
-		case LoveKernelsRealEnum : return "LoveKernelsReal";
-		case LoveKernelsImagEnum : return "LoveKernelsImag";
-		case EsaUmotionEnum : return "EsaUmotion";
-		case EsaNmotionEnum : return "EsaNmotion";
-		case EsaEmotionEnum : return "EsaEmotion";
-		case EsaXmotionEnum : return "EsaXmotion";
-		case EsaYmotionEnum : return "EsaYmotion";
-		case EsaHemisphereEnum : return "EsaHemisphere";
-		case EsaStrainratexxEnum : return "EsaStrainratexx";
-		case EsaStrainratexyEnum : return "EsaStrainratexy";
-		case EsaStrainrateyyEnum : return "EsaStrainrateyy";
-		case EsaRotationrateEnum : return "EsaRotationrate";
-		case EsaDeltathicknessEnum : return "EsaDeltathickness";
-		case EsaUElasticEnum : return "EsaUElastic";
-		case EsaHElasticEnum : return "EsaHElastic";
-		case EsaTransitionsEnum : return "EsaTransitions";
-		case EsaRequestedOutputsEnum : return "EsaRequestedOutputs";
-		case EsaNumRequestedOutputsEnum : return "EsaNumRequestedOutputs";
-		case TransientAmrFrequencyEnum : return "TransientAmrFrequency";
-		case AmrTypeEnum : return "AmrType";
-		case AmrRestartEnum : return "AmrRestart";
-		case AmrNeopzEnum : return "AmrNeopz";
-		case AmrLevelMaxEnum : return "AmrLevelMax";
-		case AmrLagEnum : return "AmrLag";
-		case AmrBamgEnum : return "AmrBamg";
-		case AmrHminEnum : return "AmrHmin";
-		case AmrHmaxEnum : return "AmrHmax";
-		case AmrFieldEnum : return "AmrField";
-		case AmrErrEnum : return "AmrErr";
-		case AmrKeepMetricEnum : return "AmrKeepMetric";
-		case AmrGradationEnum : return "AmrGradation";
-		case AmrGroundingLineResolutionEnum : return "AmrGroundingLineResolution";
-		case AmrGroundingLineDistanceEnum : return "AmrGroundingLineDistance";
-		case AmrIceFrontResolutionEnum : return "AmrIceFrontResolution";
-		case AmrIceFrontDistanceEnum : return "AmrIceFrontDistance";
-		case AmrThicknessErrorResolutionEnum : return "AmrThicknessErrorResolution";
-		case AmrThicknessErrorThresholdEnum : return "AmrThicknessErrorThreshold";
-		case AmrThicknessErrorGroupThresholdEnum : return "AmrThicknessErrorGroupThreshold";
-		case AmrThicknessErrorMaximumEnum : return "AmrThicknessErrorMaximum";
-		case AmrDeviatoricErrorResolutionEnum : return "AmrDeviatoricErrorResolution";
-		case AmrDeviatoricErrorThresholdEnum : return "AmrDeviatoricErrorThreshold";
-		case AmrDeviatoricErrorGroupThresholdEnum : return "AmrDeviatoricErrorGroupThreshold";
-		case AmrDeviatoricErrorMaximumEnum : return "AmrDeviatoricErrorMaximum";
-		case DeviatoricStressErrorEstimatorEnum : return "DeviatoricStressErrorEstimator";
-		case ThicknessErrorEstimatorEnum : return "ThicknessErrorEstimator";
-		case ParametersENDEnum : return "ParametersEND";
-		case ApproximationEnum : return "Approximation";
-		case NoneApproximationEnum : return "NoneApproximation";
-		case SIAApproximationEnum : return "SIAApproximation";
-		case SSAApproximationEnum : return "SSAApproximation";
-		case SSAHOApproximationEnum : return "SSAHOApproximation";
-		case SSAFSApproximationEnum : return "SSAFSApproximation";
-		case L1L2ApproximationEnum : return "L1L2Approximation";
-		case HOApproximationEnum : return "HOApproximation";
-		case HOFSApproximationEnum : return "HOFSApproximation";
-		case FSApproximationEnum : return "FSApproximation";
-		case FSvelocityEnum : return "FSvelocity";
-		case FSpressureEnum : return "FSpressure";
-		case InputsENDEnum : return "InputsEND";
-		case XYEnum : return "XY";
-		case XYZEnum : return "XYZ";
-		case GenericParamEnum : return "GenericParam";
-		case BoolInputEnum : return "BoolInput";
-		case BoolParamEnum : return "BoolParam";
-		case ContourEnum : return "Contour";
-		case ControlInputEnum : return "ControlInput";
-		case DatasetInputEnum : return "DatasetInput";
-		case DoubleInputEnum : return "DoubleInput";
-		case DoubleArrayInputEnum : return "DoubleArrayInput";
-		case DataSetParamEnum : return "DataSetParam";
-		case DoubleMatArrayParamEnum : return "DoubleMatArrayParam";
-		case DoubleMatParamEnum : return "DoubleMatParam";
-		case DoubleParamEnum : return "DoubleParam";
-		case DoubleVecParamEnum : return "DoubleVecParam";
-		case ElementEnum : return "Element";
-		case ElementHookEnum : return "ElementHook";
-		case HookEnum : return "Hook";
-		case ExternalResultEnum : return "ExternalResult";
-		case FileParamEnum : return "FileParam";
-		case InputEnum : return "Input";
-		case IntInputEnum : return "IntInput";
-		case IntParamEnum : return "IntParam";
-		case IntVecParamEnum : return "IntVecParam";
-		case TransientParamEnum : return "TransientParam";
-		case TransientArrayParamEnum : return "TransientArrayParam";
-		case MaticeEnum : return "Matice";
-		case MatlithoEnum : return "Matlitho";
-		case MatdamageiceEnum : return "Matdamageice";
-		case MatenhancediceEnum : return "Matenhancedice";
-		case MatestarEnum : return "Matestar";
-		case MatparEnum : return "Matpar";
-		case NodeEnum : return "Node";
-		case NumericalfluxEnum : return "Numericalflux";
-		case NeumannfluxEnum : return "Neumannflux";
-		case ParamEnum : return "Param";
-		case MoulinEnum : return "Moulin";
-		case PengridEnum : return "Pengrid";
-		case PenpairEnum : return "Penpair";
-		case ProfilerEnum : return "Profiler";
-		case MatrixParamEnum : return "MatrixParam";
-		case MassconEnum : return "Masscon";
-		case MassconaxpbyEnum : return "Massconaxpby";
-		case NodeSIdEnum : return "NodeSId";
-		case ElementSIdEnum : return "ElementSId";
-		case VectorParamEnum : return "VectorParam";
-		case RiftfrontEnum : return "Riftfront";
-		case SegmentEnum : return "Segment";
-		case SegmentRiftfrontEnum : return "SegmentRiftfront";
-		case SpcDynamicEnum : return "SpcDynamic";
-		case SpcStaticEnum : return "SpcStatic";
-		case SpcTransientEnum : return "SpcTransient";
-		case StringArrayParamEnum : return "StringArrayParam";
-		case StringParamEnum : return "StringParam";
-		case SegEnum : return "Seg";
-		case SegInputEnum : return "SegInput";
-		case TriaEnum : return "Tria";
-		case TriaInputEnum : return "TriaInput";
-		case TetraEnum : return "Tetra";
-		case TetraInputEnum : return "TetraInput";
-		case PentaEnum : return "Penta";
-		case PentaInputEnum : return "PentaInput";
-		case VertexEnum : return "Vertex";
-		case VertexPIdEnum : return "VertexPId";
-		case VertexSIdEnum : return "VertexSId";
-		case OptionEnum : return "Option";
-		case GenericOptionEnum : return "GenericOption";
-		case AdjointBalancethicknessAnalysisEnum : return "AdjointBalancethicknessAnalysis";
-		case AdjointBalancethickness2AnalysisEnum : return "AdjointBalancethickness2Analysis";
-		case AdjointHorizAnalysisEnum : return "AdjointHorizAnalysis";
-		case DefaultAnalysisEnum : return "DefaultAnalysis";
-		case BalancethicknessAnalysisEnum : return "BalancethicknessAnalysis";
-		case BalancethicknessSolutionEnum : return "BalancethicknessSolution";
-		case Balancethickness2AnalysisEnum : return "Balancethickness2Analysis";
-		case Balancethickness2SolutionEnum : return "Balancethickness2Solution";
-		case BalancethicknessSoftAnalysisEnum : return "BalancethicknessSoftAnalysis";
-		case BalancethicknessSoftSolutionEnum : return "BalancethicknessSoftSolution";
-		case BalancevelocityAnalysisEnum : return "BalancevelocityAnalysis";
-		case BalancevelocitySolutionEnum : return "BalancevelocitySolution";
-		case L2ProjectionEPLAnalysisEnum : return "L2ProjectionEPLAnalysis";
-		case L2ProjectionBaseAnalysisEnum : return "L2ProjectionBaseAnalysis";
-		case BedSlopeSolutionEnum : return "BedSlopeSolution";
-		case DamageEvolutionSolutionEnum : return "DamageEvolutionSolution";
-		case DamageEvolutionAnalysisEnum : return "DamageEvolutionAnalysis";
-		case StressbalanceAnalysisEnum : return "StressbalanceAnalysis";
-		case StressbalanceSIAAnalysisEnum : return "StressbalanceSIAAnalysis";
-		case StressbalanceSolutionEnum : return "StressbalanceSolution";
-		case StressbalanceVerticalAnalysisEnum : return "StressbalanceVerticalAnalysis";
-		case EnthalpyAnalysisEnum : return "EnthalpyAnalysis";
-		case HydrologyShreveAnalysisEnum : return "HydrologyShreveAnalysis";
-		case HydrologyDCInefficientAnalysisEnum : return "HydrologyDCInefficientAnalysis";
-		case HydrologyDCEfficientAnalysisEnum : return "HydrologyDCEfficientAnalysis";
-		case HydrologySommersAnalysisEnum : return "HydrologySommersAnalysis";
-		case HydrologySolutionEnum : return "HydrologySolution";
-		case MeltingAnalysisEnum : return "MeltingAnalysis";
-		case MasstransportAnalysisEnum : return "MasstransportAnalysis";
-		case MasstransportSolutionEnum : return "MasstransportSolution";
-		case FreeSurfaceBaseAnalysisEnum : return "FreeSurfaceBaseAnalysis";
-		case FreeSurfaceTopAnalysisEnum : return "FreeSurfaceTopAnalysis";
-		case ExtrudeFromBaseAnalysisEnum : return "ExtrudeFromBaseAnalysis";
-		case ExtrudeFromTopAnalysisEnum : return "ExtrudeFromTopAnalysis";
-		case DepthAverageAnalysisEnum : return "DepthAverageAnalysis";
-		case SealevelriseSolutionEnum : return "SealevelriseSolution";
-		case SealevelriseAnalysisEnum : return "SealevelriseAnalysis";
-		case SteadystateSolutionEnum : return "SteadystateSolution";
-		case SurfaceSlopeSolutionEnum : return "SurfaceSlopeSolution";
-		case SmoothAnalysisEnum : return "SmoothAnalysis";
-		case ThermalAnalysisEnum : return "ThermalAnalysis";
-		case ThermalSolutionEnum : return "ThermalSolution";
-		case TransientSolutionEnum : return "TransientSolution";
-		case UzawaPressureAnalysisEnum : return "UzawaPressureAnalysis";
-		case GiaSolutionEnum : return "GiaSolution";
-		case GiaIvinsAnalysisEnum : return "GiaIvinsAnalysis";
-		case EsaSolutionEnum : return "EsaSolution";
-		case EsaAnalysisEnum : return "EsaAnalysis";
-		case LoveSolutionEnum : return "LoveSolution";
-		case LoveAnalysisEnum : return "LoveAnalysis";
-		case LevelsetAnalysisEnum : return "LevelsetAnalysis";
-		case ExtrapolationAnalysisEnum : return "ExtrapolationAnalysis";
-		case GaussSegEnum : return "GaussSeg";
-		case GaussTriaEnum : return "GaussTria";
-		case GaussTetraEnum : return "GaussTetra";
-		case GaussPentaEnum : return "GaussPenta";
+		case StrainRateEnum : return "StrainRate";
+		case StressbalanceViscosityOvershootEnum : return "StressbalanceViscosityOvershoot";
+		case StressTensorEnum : return "StressTensor";
+		case SubelementMigration4Enum : return "SubelementMigration4";
+		case TimesteppingTimeAdaptEnum : return "TimesteppingTimeAdapt";
 		case TriangleInterpEnum : return "TriangleInterp";
-		case BilinearInterpEnum : return "BilinearInterp";
-		case NearestInterpEnum : return "NearestInterp";
-		case MinVelEnum : return "MinVel";
-		case MaxVelEnum : return "MaxVel";
-		case MinVxEnum : return "MinVx";
-		case MaxVxEnum : return "MaxVx";
-		case MaxAbsVxEnum : return "MaxAbsVx";
-		case MinVyEnum : return "MinVy";
-		case MaxVyEnum : return "MaxVy";
-		case MaxAbsVyEnum : return "MaxAbsVy";
-		case MinVzEnum : return "MinVz";
-		case MaxVzEnum : return "MaxVz";
-		case MaxAbsVzEnum : return "MaxAbsVz";
-		case FloatingAreaEnum : return "FloatingArea";
-		case FloatingAreaScaledEnum : return "FloatingAreaScaled";
-		case GroundedAreaEnum : return "GroundedArea";
-		case GroundedAreaScaledEnum : return "GroundedAreaScaled";
-		case IceMassEnum : return "IceMass";
-		case IceMassScaledEnum : return "IceMassScaled";
-		case IceVolumeEnum : return "IceVolume";
-		case IceVolumeScaledEnum : return "IceVolumeScaled";
-		case IceVolumeAboveFloatationEnum : return "IceVolumeAboveFloatation";
-		case IceVolumeAboveFloatationScaledEnum : return "IceVolumeAboveFloatationScaled";
-		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 P0Enum : return "P0";
-		case P0ArrayEnum : return "P0Array";
-		case P1Enum : return "P1";
-		case P1DGEnum : return "P1DG";
-		case P1bubbleEnum : return "P1bubble";
-		case P1bubblecondensedEnum : return "P1bubblecondensed";
-		case P2Enum : return "P2";
-		case P2bubbleEnum : return "P2bubble";
-		case P2bubblecondensedEnum : return "P2bubblecondensed";
-		case P2xP1Enum : return "P2xP1";
-		case P1xP2Enum : return "P1xP2";
-		case P1xP3Enum : return "P1xP3";
-		case P1xP4Enum : return "P1xP4";
-		case P2xP4Enum : return "P2xP4";
-		case P1P1Enum : return "P1P1";
-		case P1P1GLSEnum : return "P1P1GLS";
-		case MINIEnum : return "MINI";
-		case MINIcondensedEnum : return "MINIcondensed";
-		case TaylorHoodEnum : return "TaylorHood";
-		case LATaylorHoodEnum : return "LATaylorHood";
-		case XTaylorHoodEnum : return "XTaylorHood";
-		case OneLayerP4zEnum : return "OneLayerP4z";
-		case CrouzeixRaviartEnum : return "CrouzeixRaviart";
-		case LACrouzeixRaviartEnum : return "LACrouzeixRaviart";
-		case ClosedEnum : return "Closed";
-		case FreeEnum : return "Free";
-		case OpenEnum : return "Open";
-		case AirEnum : return "Air";
-		case IceEnum : return "Ice";
-		case MelangeEnum : return "Melange";
-		case WaterEnum : return "Water";
-		case DataSetEnum : return "DataSet";
-		case ConstraintsEnum : return "Constraints";
-		case LoadsEnum : return "Loads";
-		case MaterialsEnum : return "Materials";
-		case NodesEnum : return "Nodes";
-		case ContoursEnum : return "Contours";
-		case ParametersEnum : return "Parameters";
-		case VerticesEnum : return "Vertices";
-		case ResultsEnum : return "Results";
 		case MaximumNumberOfDefinitionsEnum : return "MaximumNumberOfDefinitions";
 		default : return "unknown";
 
Index: ../trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp
===================================================================
--- ../trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp	(revision 22595)
+++ ../trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp	(revision 22596)
@@ -16,657 +16,1029 @@
    int  stage=1;
 
    if(stage==1){
-	      if (strcmp(name,"FemModel")==0) return FemModelEnum;
-	      else if (strcmp(name,"ParametersSTART")==0) return ParametersSTARTEnum;
+	      if (strcmp(name,"ParametersSTART")==0) return ParametersSTARTEnum;
 	      else if (strcmp(name,"AdolcParam")==0) return AdolcParamEnum;
-	      else if (strcmp(name,"FSSolver")==0) return FSSolverEnum;
-	      else if (strcmp(name,"FemModelComm")==0) return FemModelCommEnum;
-	      else if (strcmp(name,"WorldComm")==0) return WorldCommEnum;
-	      else if (strcmp(name,"IcecapToEarthComm")==0) return IcecapToEarthCommEnum;
-	      else if (strcmp(name,"ToMITgcmComm")==0) return ToMITgcmCommEnum;
-	      else if (strcmp(name,"NumModels")==0) return NumModelsEnum;
-	      else if (strcmp(name,"ModelId")==0) return ModelIdEnum;
-	      else if (strcmp(name,"EarthId")==0) return EarthIdEnum;
-	      else if (strcmp(name,"SolutionType")==0) return SolutionTypeEnum;
+	      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,"AnalysisCounter")==0) return AnalysisCounterEnum;
-	      else if (strcmp(name,"ConfigurationType")==0) return ConfigurationTypeEnum;
-	      else if (strcmp(name,"InputToExtrude")==0) return InputToExtrudeEnum;
-	      else if (strcmp(name,"InputToL2Project")==0) return InputToL2ProjectEnum;
-	      else if (strcmp(name,"InputToDepthaverageIn")==0) return InputToDepthaverageInEnum;
-	      else if (strcmp(name,"InputToDepthaverageOut")==0) return InputToDepthaverageOutEnum;
-	      else if (strcmp(name,"InputToSmooth")==0) return InputToSmoothEnum;
-	      else if (strcmp(name,"SmoothThicknessMultiplier")==0) return SmoothThicknessMultiplierEnum;
-	      else if (strcmp(name,"LevelsetStabilization")==0) return LevelsetStabilizationEnum;
-	      else if (strcmp(name,"TimesteppingType")==0) return TimesteppingTypeEnum;
-	      else if (strcmp(name,"FixedTimestepping")==0) return FixedTimesteppingEnum;
-	      else if (strcmp(name,"AdaptiveTimestepping")==0) return AdaptiveTimesteppingEnum;
-	      else if (strcmp(name,"TimesteppingTimeStepMin")==0) return TimesteppingTimeStepMinEnum;
-	      else if (strcmp(name,"TimesteppingTimeStepMax")==0) return TimesteppingTimeStepMaxEnum;
-	      else if (strcmp(name,"InputsSTART")==0) return InputsSTARTEnum;
-	      else if (strcmp(name,"AutodiffIsautodiff")==0) return AutodiffIsautodiffEnum;
-	      else if (strcmp(name,"AutodiffNumDependents")==0) return AutodiffNumDependentsEnum;
+	      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,"AutodiffNumIndependents")==0) return AutodiffNumIndependentsEnum;
-	      else if (strcmp(name,"AutodiffJacobian")==0) return AutodiffJacobianEnum;
-	      else if (strcmp(name,"AutodiffXp")==0) return AutodiffXpEnum;
 	      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,"AutodiffFosReverseIndex")==0) return AutodiffFosReverseIndexEnum;
-	      else if (strcmp(name,"AutodiffKeep")==0) return AutodiffKeepEnum;
+	      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,"AutodiffLbufsize")==0) return AutodiffLbufsizeEnum;
-	      else if (strcmp(name,"AutodiffCbufsize")==0) return AutodiffCbufsizeEnum;
 	      else if (strcmp(name,"AutodiffTbufsize")==0) return AutodiffTbufsizeEnum;
-	      else if (strcmp(name,"AutodiffGcTriggerRatio")==0) return AutodiffGcTriggerRatioEnum;
-	      else if (strcmp(name,"AutodiffGcTriggerMaxSize")==0) return AutodiffGcTriggerMaxSizeEnum;
+	      else if (strcmp(name,"AutodiffXp")==0) return AutodiffXpEnum;
 	      else if (strcmp(name,"BalancethicknessStabilization")==0) return BalancethicknessStabilizationEnum;
-	      else if (strcmp(name,"BalancethicknessThickeningRate")==0) return BalancethicknessThickeningRateEnum;
+	      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,"BasalforcingsGeothermalflux")==0) return BasalforcingsGeothermalfluxEnum;
-	      else if (strcmp(name,"BasalforcingsGroundediceMeltingRate")==0) return BasalforcingsGroundediceMeltingRateEnum;
-	      else if (strcmp(name,"BasalforcingsFloatingiceMeltingRate")==0) return BasalforcingsFloatingiceMeltingRateEnum;
-	      else if (strcmp(name,"BasalforcingsDeepwaterMeltingRate")==0) return BasalforcingsDeepwaterMeltingRateEnum;
-	      else if (strcmp(name,"BasalforcingsDeepwaterElevation")==0) return BasalforcingsDeepwaterElevationEnum;
-	      else if (strcmp(name,"BasalforcingsUpperwaterElevation")==0) return BasalforcingsUpperwaterElevationEnum;
+	      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,"BasalforcingsThresholdThickness")==0) return BasalforcingsThresholdThicknessEnum;
-	      else if (strcmp(name,"BasalforcingsUpperdepthMelt")==0) return BasalforcingsUpperdepthMeltEnum;
-	      else if (strcmp(name,"BasalforcingsMantleconductivity")==0) return BasalforcingsMantleconductivityEnum;
 	      else if (strcmp(name,"BasalforcingsNusselt")==0) return BasalforcingsNusseltEnum;
-	      else if (strcmp(name,"BasalforcingsDtbg")==0) return BasalforcingsDtbgEnum;
+	      else if (strcmp(name,"BasalforcingsPicoFarOceansalinity")==0) return BasalforcingsPicoFarOceansalinityEnum;
+	      else if (strcmp(name,"BasalforcingsPicoGammaT")==0) return BasalforcingsPicoGammaTEnum;
+	      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,"BasalforcingsTopplumedepth")==0) return BasalforcingsTopplumedepthEnum;
-	      else if (strcmp(name,"BasalforcingsBottomplumedepth")==0) return BasalforcingsBottomplumedepthEnum;
 	      else if (strcmp(name,"BasalforcingsPlumex")==0) return BasalforcingsPlumexEnum;
 	      else if (strcmp(name,"BasalforcingsPlumey")==0) return BasalforcingsPlumeyEnum;
-	      else if (strcmp(name,"BasalforcingsCrustthickness")==0) return BasalforcingsCrustthicknessEnum;
+	      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,"BasalforcingsUppercrustheat")==0) return BasalforcingsUppercrustheatEnum;
-	      else if (strcmp(name,"BasalforcingsLowercrustheat")==0) return BasalforcingsLowercrustheatEnum;
-	      else if (strcmp(name,"FloatingMeltRate")==0) return FloatingMeltRateEnum;
-	      else if (strcmp(name,"LinearFloatingMeltRate")==0) return LinearFloatingMeltRateEnum;
-	      else if (strcmp(name,"MismipFloatingMeltRate")==0) return MismipFloatingMeltRateEnum;
-	      else if (strcmp(name,"MantlePlumeGeothermalFlux")==0) return MantlePlumeGeothermalFluxEnum;
-	      else if (strcmp(name,"BasalforcingsPico")==0) return BasalforcingsPicoEnum;
-	      else if (strcmp(name,"BasalforcingsPicoNumBasins")==0) return BasalforcingsPicoNumBasinsEnum;
-	      else if (strcmp(name,"BasalforcingsPicoBasinId")==0) return BasalforcingsPicoBasinIdEnum;
-	      else if (strcmp(name,"BasalforcingsPicoMaxboxcount")==0) return BasalforcingsPicoMaxboxcountEnum;
-	      else if (strcmp(name,"BasalforcingsPicoBoxId")==0) return BasalforcingsPicoBoxIdEnum;
-	      else if (strcmp(name,"BasalforcingsPicoOverturningCoeff")==0) return BasalforcingsPicoOverturningCoeffEnum;
-	      else if (strcmp(name,"BasalforcingsPicoGammaT")==0) return BasalforcingsPicoGammaTEnum;
-	      else if (strcmp(name,"BasalforcingsPicoFarOceantemperature")==0) return BasalforcingsPicoFarOceantemperatureEnum;
-	      else if (strcmp(name,"BasalforcingsPicoFarOceansalinity")==0) return BasalforcingsPicoFarOceansalinityEnum;
-	      else if (strcmp(name,"DistanceToGroundingline")==0) return DistanceToGroundinglineEnum;
-	      else if (strcmp(name,"DistanceToCalvingfront")==0) return DistanceToCalvingfrontEnum;
-	      else if (strcmp(name,"Bed")==0) return BedEnum;
-	      else if (strcmp(name,"Base")==0) return BaseEnum;
-	      else if (strcmp(name,"ConstantsG")==0) return ConstantsGEnum;
-	      else if (strcmp(name,"ConstantsReferencetemperature")==0) return ConstantsReferencetemperatureEnum;
+	      else if (strcmp(name,"BasalforcingsUpperdepthMelt")==0) return BasalforcingsUpperdepthMeltEnum;
+	      else if (strcmp(name,"BasalforcingsUpperwaterElevation")==0) return BasalforcingsUpperwaterElevationEnum;
+	      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,"ConstantsYts")==0) return ConstantsYtsEnum;
-	      else if (strcmp(name,"DependentObject")==0) return DependentObjectEnum;
-	      else if (strcmp(name,"StressbalanceAbstol")==0) return StressbalanceAbstolEnum;
-	      else if (strcmp(name,"StressbalanceConvergenceNumSteps")==0) return StressbalanceConvergenceNumStepsEnum;
-	      else if (strcmp(name,"StressbalanceIsnewton")==0) return StressbalanceIsnewtonEnum;
-	      else if (strcmp(name,"StressbalanceMaxiter")==0) return StressbalanceMaxiterEnum;
-	      else if (strcmp(name,"StressbalancePenaltyFactor")==0) return StressbalancePenaltyFactorEnum;
-	      else if (strcmp(name,"StressbalanceReltol")==0) return StressbalanceReltolEnum;
-	      else if (strcmp(name,"StressbalanceNumRequestedOutputs")==0) return StressbalanceNumRequestedOutputsEnum;
-	      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,"StressbalanceFSreconditioning")==0) return StressbalanceFSreconditioningEnum;
-	      else if (strcmp(name,"StressbalanceViscosityOvershoot")==0) return StressbalanceViscosityOvershootEnum;
-	      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,"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 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,"FlowequationIsL1L2")==0) return FlowequationIsL1L2Enum;
-	      else if (strcmp(name,"FlowequationIsHO")==0) return FlowequationIsHOEnum;
-	      else if (strcmp(name,"FlowequationIsFS")==0) return FlowequationIsFSEnum;
-	      else if (strcmp(name,"FlowequationFeFS")==0) return FlowequationFeFSEnum;
-	      else if (strcmp(name,"FlowequationBorderFS")==0) return FlowequationBorderFSEnum;
-	      else if (strcmp(name,"FrictionAs")==0) return FrictionAsEnum;
-	      else if (strcmp(name,"FrictionCoefficient")==0) return FrictionCoefficientEnum;
-	      else if (strcmp(name,"FrictionCoefficientcoulomb")==0) return FrictionCoefficientcoulombEnum;
-	      else if (strcmp(name,"FrictionPressureAdjustedTemperature")==0) return FrictionPressureAdjustedTemperatureEnum;
-	      else if (strcmp(name,"FrictionP")==0) return FrictionPEnum;
-	      else if (strcmp(name,"FrictionQ")==0) return FrictionQEnum;
-	      else if (strcmp(name,"FrictionM")==0) return FrictionMEnum;
+	      else if (strcmp(name,"FrictionCoupling")==0) return FrictionCouplingEnum;
+	      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,"GiaCrossSectionShape")==0) return GiaCrossSectionShapeEnum;
+	      else if (strcmp(name,"GroundinglineMigration")==0) return GroundinglineMigrationEnum;
+	      else if (strcmp(name,"HydrologydcEplflipLock")==0) return HydrologydcEplflipLockEnum;
+	      else if (strcmp(name,"HydrologydcEplThickComp")==0) return HydrologydcEplThickCompEnum;
+	      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 stage=2;
    }
    if(stage==2){
-	      if (strcmp(name,"FrictionC")==0) return FrictionCEnum;
-	      else if (strcmp(name,"FrictionLaw")==0) return FrictionLawEnum;
-	      else if (strcmp(name,"FrictionGamma")==0) return FrictionGammaEnum;
-	      else if (strcmp(name,"FrictionF")==0) return FrictionFEnum;
-	      else if (strcmp(name,"FrictionWaterLayer")==0) return FrictionWaterLayerEnum;
-	      else if (strcmp(name,"FrictionEffectivePressure")==0) return FrictionEffectivePressureEnum;
-	      else if (strcmp(name,"FrictionCoupling")==0) return FrictionCouplingEnum;
-	      else if (strcmp(name,"GeometryHydrostaticRatio")==0) return GeometryHydrostaticRatioEnum;
+	      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,"Hydrologydt")==0) return HydrologydtEnum;
 	      else if (strcmp(name,"HydrologyModel")==0) return HydrologyModelEnum;
 	      else if (strcmp(name,"HydrologyNumRequestedOutputs")==0) return HydrologyNumRequestedOutputsEnum;
+	      else if (strcmp(name,"HydrologyRelaxation")==0) return HydrologyRelaxationEnum;
 	      else if (strcmp(name,"HydrologyRequestedOutputs")==0) return HydrologyRequestedOutputsEnum;
-	      else if (strcmp(name,"Hydrologyshreve")==0) return HydrologyshreveEnum;
+	      else if (strcmp(name,"HydrologySedimentKmax")==0) return HydrologySedimentKmaxEnum;
 	      else if (strcmp(name,"HydrologyshreveStabilization")==0) return HydrologyshreveStabilizationEnum;
-	      else if (strcmp(name,"Hydrologydc")==0) return HydrologydcEnum;
-	      else if (strcmp(name,"Hydrologydt")==0) return HydrologydtEnum;
 	      else if (strcmp(name,"HydrologyStepsPerStep")==0) return HydrologyStepsPerStepEnum;
-	      else if (strcmp(name,"SedimentHead")==0) return SedimentHeadEnum;
-	      else if (strcmp(name,"SedimentHeadOld")==0) return SedimentHeadOldEnum;
-	      else if (strcmp(name,"SedimentHeadStacked")==0) return SedimentHeadStackedEnum;
-	      else if (strcmp(name,"SedimentHeadTimeAverage")==0) return SedimentHeadTimeAverageEnum;
-	      else if (strcmp(name,"SedimentHeadResidual")==0) return SedimentHeadResidualEnum;
-	      else if (strcmp(name,"EffectivePressure")==0) return EffectivePressureEnum;
-	      else if (strcmp(name,"EffectivePressureStacked")==0) return EffectivePressureStackedEnum;
-	      else if (strcmp(name,"EffectivePressureTimeAverage")==0) return EffectivePressureTimeAverageEnum;
-	      else if (strcmp(name,"EplHead")==0) return EplHeadEnum;
-	      else if (strcmp(name,"EplHeadOld")==0) return EplHeadOldEnum;
-	      else if (strcmp(name,"EplHeadStacked")==0) return EplHeadStackedEnum;
-	      else if (strcmp(name,"EplHeadTimeAverage")==0) return EplHeadTimeAverageEnum;
-	      else if (strcmp(name,"EplHeadSlopeX")==0) return EplHeadSlopeXEnum;
-	      else if (strcmp(name,"EplHeadSlopeY")==0) return EplHeadSlopeYEnum;
-	      else if (strcmp(name,"EplZigZagCounter")==0) return EplZigZagCounterEnum;
-	      else if (strcmp(name,"HydrologydcMaxIter")==0) return HydrologydcMaxIterEnum;
-	      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,"HydrologydcSedimentTransmitivity")==0) return HydrologydcSedimentTransmitivityEnum;
-	      else if (strcmp(name,"HydrologydcWaterCompressibility")==0) return HydrologydcWaterCompressibilityEnum;
-	      else if (strcmp(name,"HydrologydcMaskEplactiveNode")==0) return HydrologydcMaskEplactiveNodeEnum;
-	      else if (strcmp(name,"HydrologydcMaskEplactiveElt")==0) return HydrologydcMaskEplactiveEltEnum;
-	      else if (strcmp(name,"HydrologydcEplCompressibility")==0) return HydrologydcEplCompressibilityEnum;
-	      else if (strcmp(name,"HydrologydcEplPorosity")==0) return HydrologydcEplPorosityEnum;
-	      else if (strcmp(name,"HydrologydcEplInitialThickness")==0) return HydrologydcEplInitialThicknessEnum;
-	      else if (strcmp(name,"HydrologydcEplColapseThickness")==0) return HydrologydcEplColapseThicknessEnum;
-	      else if (strcmp(name,"HydrologydcEplMaxThickness")==0) return HydrologydcEplMaxThicknessEnum;
-	      else if (strcmp(name,"HydrologydcEplThickness")==0) return HydrologydcEplThicknessEnum;
-	      else if (strcmp(name,"HydrologydcEplThicknessOld")==0) return HydrologydcEplThicknessOldEnum;
-	      else if (strcmp(name,"HydrologydcEplThicknessStacked")==0) return HydrologydcEplThicknessStackedEnum;
-	      else if (strcmp(name,"HydrologydcEplThicknessTimeAverage")==0) return HydrologydcEplThicknessTimeAverageEnum;
-	      else if (strcmp(name,"HydrologydcEplThickComp")==0) return HydrologydcEplThickCompEnum;
-	      else if (strcmp(name,"HydrologydcEplConductivity")==0) return HydrologydcEplConductivityEnum;
-	      else if (strcmp(name,"HydrologydcIsefficientlayer")==0) return HydrologydcIsefficientlayerEnum;
-	      else if (strcmp(name,"HydrologydcSedimentlimitFlag")==0) return HydrologydcSedimentlimitFlagEnum;
-	      else if (strcmp(name,"HydrologydcSedimentlimit")==0) return HydrologydcSedimentlimitEnum;
-	      else if (strcmp(name,"HydrologydcTransferFlag")==0) return HydrologydcTransferFlagEnum;
-	      else if (strcmp(name,"HydrologydcUnconfinedFlag")==0) return HydrologydcUnconfinedFlagEnum;
-	      else if (strcmp(name,"HydrologydcLeakageFactor")==0) return HydrologydcLeakageFactorEnum;
-	      else if (strcmp(name,"HydrologydcPenaltyFactor")==0) return HydrologydcPenaltyFactorEnum;
-	      else if (strcmp(name,"HydrologydcPenaltyLock")==0) return HydrologydcPenaltyLockEnum;
-	      else if (strcmp(name,"HydrologydcEplflipLock")==0) return HydrologydcEplflipLockEnum;
-	      else if (strcmp(name,"HydrologydcBasalMoulinInput")==0) return HydrologydcBasalMoulinInputEnum;
-	      else if (strcmp(name,"HydrologySedimentKmax")==0) return HydrologySedimentKmaxEnum;
-	      else if (strcmp(name,"Hydrologysommers")==0) return HydrologysommersEnum;
-	      else if (strcmp(name,"HydrologyHead")==0) return HydrologyHeadEnum;
-	      else if (strcmp(name,"HydrologyHeadOld")==0) return HydrologyHeadOldEnum;
-	      else if (strcmp(name,"HydrologyGapHeight")==0) return HydrologyGapHeightEnum;
-	      else if (strcmp(name,"HydrologyBumpSpacing")==0) return HydrologyBumpSpacingEnum;
-	      else if (strcmp(name,"HydrologyBumpHeight")==0) return HydrologyBumpHeightEnum;
-	      else if (strcmp(name,"HydrologyEnglacialInput")==0) return HydrologyEnglacialInputEnum;
-	      else if (strcmp(name,"HydrologyMoulinInput")==0) return HydrologyMoulinInputEnum;
-	      else if (strcmp(name,"HydrologyReynolds")==0) return HydrologyReynoldsEnum;
-	      else if (strcmp(name,"HydrologyNeumannflux")==0) return HydrologyNeumannfluxEnum;
-	      else if (strcmp(name,"HydrologyRelaxation")==0) return HydrologyRelaxationEnum;
-	      else if (strcmp(name,"HydrologyBasalFlux")==0) return HydrologyBasalFluxEnum;
 	      else if (strcmp(name,"HydrologyStorage")==0) return HydrologyStorageEnum;
-	      else if (strcmp(name,"DegreeOfChannelization")==0) return DegreeOfChannelizationEnum;
+	      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,"InversionCostFunctionThreshold")==0) return InversionCostFunctionThresholdEnum;
-	      else if (strcmp(name,"InversionCostFunctionsCoefficients")==0) return InversionCostFunctionsCoefficientsEnum;
 	      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,"InversionType")==0) return InversionTypeEnum;
-	      else if (strcmp(name,"InversionIncompleteAdjoint")==0) return InversionIncompleteAdjointEnum;
+	      else if (strcmp(name,"InversionMaxiter")==0) return InversionMaxiterEnum;
 	      else if (strcmp(name,"InversionMaxiterPerStep")==0) return InversionMaxiterPerStepEnum;
-	      else if (strcmp(name,"InversionMaxiter")==0) return InversionMaxiterEnum;
 	      else if (strcmp(name,"InversionMaxsteps")==0) return InversionMaxstepsEnum;
-	      else if (strcmp(name,"InversionFatol")==0) return InversionFatolEnum;
-	      else if (strcmp(name,"InversionFrtol")==0) return InversionFrtolEnum;
-	      else if (strcmp(name,"InversionGatol")==0) return InversionGatolEnum;
-	      else if (strcmp(name,"InversionGrtol")==0) return InversionGrtolEnum;
-	      else if (strcmp(name,"InversionGttol")==0) return InversionGttolEnum;
-	      else if (strcmp(name,"InversionAlgorithm")==0) return InversionAlgorithmEnum;
 	      else if (strcmp(name,"InversionNsteps")==0) return InversionNstepsEnum;
-	      else if (strcmp(name,"InversionDxmin")==0) return InversionDxminEnum;
 	      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,"InversionThicknessObs")==0) return InversionThicknessObsEnum;
-	      else if (strcmp(name,"InversionSurfaceObs")==0) return InversionSurfaceObsEnum;
-	      else if (strcmp(name,"InversionVxObs")==0) return InversionVxObsEnum;
-	      else if (strcmp(name,"InversionVyObs")==0) return InversionVyObsEnum;
-	      else if (strcmp(name,"InversionVzObs")==0) return InversionVzObsEnum;
-	      else if (strcmp(name,"InversionVelObs")==0) return InversionVelObsEnum;
-	      else if (strcmp(name,"MaskIceLevelset")==0) return MaskIceLevelsetEnum;
-	      else if (strcmp(name,"MaskOceanLevelset")==0) return MaskOceanLevelsetEnum;
-	      else if (strcmp(name,"MaskLandLevelset")==0) return MaskLandLevelsetEnum;
-	      else if (strcmp(name,"MaterialsBeta")==0) return MaterialsBetaEnum;
-	      else if (strcmp(name,"MaterialsHeatcapacity")==0) return MaterialsHeatcapacityEnum;
-	      else if (strcmp(name,"MaterialsLatentheat")==0) return MaterialsLatentheatEnum;
-	      else if (strcmp(name,"MaterialsMeltingpoint")==0) return MaterialsMeltingpointEnum;
-	      else if (strcmp(name,"MaterialsMixedLayerCapacity")==0) return MaterialsMixedLayerCapacityEnum;
-	      else if (strcmp(name,"MaterialsRheologyB")==0) return MaterialsRheologyBEnum;
-	      else if (strcmp(name,"MaterialsRheologyBbar")==0) return MaterialsRheologyBbarEnum;
-	      else if (strcmp(name,"MaterialsRheologyLaw")==0) return MaterialsRheologyLawEnum;
-	      else if (strcmp(name,"MaterialsRheologyN")==0) return MaterialsRheologyNEnum;
-	      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 stage=3;
-   }
-   if(stage==3){
-	      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,"DamageD")==0) return DamageDEnum;
-	      else if (strcmp(name,"DamageF")==0) return DamageFEnum;
-	      else if (strcmp(name,"DamageDbar")==0) return DamageDbarEnum;
-	      else if (strcmp(name,"DamageLaw")==0) return DamageLawEnum;
-	      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,"DamageC4")==0) return DamageC4Enum;
-	      else if (strcmp(name,"DamageElementinterp")==0) return DamageElementinterpEnum;
-	      else if (strcmp(name,"DamageHealing")==0) return DamageHealingEnum;
-	      else if (strcmp(name,"DamageStressThreshold")==0) return DamageStressThresholdEnum;
-	      else if (strcmp(name,"DamageKappa")==0) return DamageKappaEnum;
-	      else if (strcmp(name,"DamageStabilization")==0) return DamageStabilizationEnum;
-	      else if (strcmp(name,"DamageMaxiter")==0) return DamageMaxiterEnum;
-	      else if (strcmp(name,"DamageMaxDamage")==0) return DamageMaxDamageEnum;
-	      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,"Damage")==0) return DamageEnum;
-	      else if (strcmp(name,"NewDamage")==0) return NewDamageEnum;
-	      else if (strcmp(name,"StressIntensityFactor")==0) return StressIntensityFactorEnum;
-	      else if (strcmp(name,"CalvingLaw")==0) return CalvingLawEnum;
-	      else if (strcmp(name,"CalvingCalvingrate")==0) return CalvingCalvingrateEnum;
-	      else if (strcmp(name,"CalvingMeltingrate")==0) return CalvingMeltingrateEnum;
-	      else if (strcmp(name,"CalvingHeightAboveFloatation")==0) return CalvingHeightAboveFloatationEnum;
-	      else if (strcmp(name,"CalvingLevermann")==0) return CalvingLevermannEnum;
-	      else if (strcmp(name,"CalvingVonmises")==0) return CalvingVonmisesEnum;
-	      else if (strcmp(name,"CalvingMinthickness")==0) return CalvingMinthicknessEnum;
-	      else if (strcmp(name,"CalvingHab")==0) return CalvingHabEnum;
-	      else if (strcmp(name,"CalvingHabFraction")==0) return CalvingHabFractionEnum;
-	      else if (strcmp(name,"CalvingCrevasseDepth")==0) return CalvingCrevasseDepthEnum;
-	      else if (strcmp(name,"CalvingDev2")==0) return CalvingDev2Enum;
-	      else if (strcmp(name,"SurfaceCrevasse")==0) return SurfaceCrevasseEnum;
-	      else if (strcmp(name,"BasalCrevasse")==0) return BasalCrevasseEnum;
-	      else if (strcmp(name,"CrevasseDepth")==0) return CrevasseDepthEnum;
-	      else if (strcmp(name,"Waterheight")==0) return WaterheightEnum;
-	      else if (strcmp(name,"DefaultCalving")==0) return DefaultCalvingEnum;
-	      else if (strcmp(name,"CalvinglevermannCoeff")==0) return CalvinglevermannCoeffEnum;
-	      else if (strcmp(name,"CalvinglevermannMeltingrate")==0) return CalvinglevermannMeltingrateEnum;
-	      else if (strcmp(name,"CalvingdevCoeff")==0) return CalvingdevCoeffEnum;
-	      else if (strcmp(name,"Calvingratex")==0) return CalvingratexEnum;
-	      else if (strcmp(name,"Calvingratey")==0) return CalvingrateyEnum;
-	      else if (strcmp(name,"CalvingratexAverage")==0) return CalvingratexAverageEnum;
-	      else if (strcmp(name,"CalvingrateyAverage")==0) return CalvingrateyAverageEnum;
-	      else if (strcmp(name,"CalvingStressThresholdGroundedice")==0) return CalvingStressThresholdGroundediceEnum;
-	      else if (strcmp(name,"CalvingStressThresholdFloatingice")==0) return CalvingStressThresholdFloatingiceEnum;
-	      else if (strcmp(name,"CalvingMax")==0) return CalvingMaxEnum;
-	      else if (strcmp(name,"SigmaVM")==0) return SigmaVMEnum;
-	      else if (strcmp(name,"StrainRateparallel")==0) return StrainRateparallelEnum;
-	      else if (strcmp(name,"StrainRateperpendicular")==0) return StrainRateperpendicularEnum;
-	      else if (strcmp(name,"StrainRateeffective")==0) return StrainRateeffectiveEnum;
-	      else if (strcmp(name,"MaterialsRhoIce")==0) return MaterialsRhoIceEnum;
-	      else if (strcmp(name,"MaterialsRhoSeawater")==0) return MaterialsRhoSeawaterEnum;
-	      else if (strcmp(name,"MaterialsRhoFreshwater")==0) return MaterialsRhoFreshwaterEnum;
-	      else if (strcmp(name,"MaterialsMuWater")==0) return MaterialsMuWaterEnum;
-	      else if (strcmp(name,"MaterialsThermalExchangeVelocity")==0) return MaterialsThermalExchangeVelocityEnum;
-	      else if (strcmp(name,"MaterialsThermalconductivity")==0) return MaterialsThermalconductivityEnum;
-	      else if (strcmp(name,"MaterialsTemperateiceconductivity")==0) return MaterialsTemperateiceconductivityEnum;
-	      else if (strcmp(name,"MaterialsLithosphereShearModulus")==0) return MaterialsLithosphereShearModulusEnum;
-	      else if (strcmp(name,"MaterialsLithosphereDensity")==0) return MaterialsLithosphereDensityEnum;
-	      else if (strcmp(name,"MaterialsMantleShearModulus")==0) return MaterialsMantleShearModulusEnum;
-	      else if (strcmp(name,"MaterialsMantleDensity")==0) return MaterialsMantleDensityEnum;
-	      else if (strcmp(name,"MaterialsEarthDensity")==0) return MaterialsEarthDensityEnum;
-	      else if (strcmp(name,"MeshAverageVertexConnectivity")==0) return MeshAverageVertexConnectivityEnum;
-	      else if (strcmp(name,"MeshLat")==0) return MeshLatEnum;
-	      else if (strcmp(name,"MeshLong")==0) return MeshLongEnum;
-	      else if (strcmp(name,"MeshX")==0) return MeshXEnum;
-	      else if (strcmp(name,"MeshY")==0) return MeshYEnum;
-	      else if (strcmp(name,"MeshZ")==0) return MeshZEnum;
-	      else if (strcmp(name,"MeshScaleFactor")==0) return MeshScaleFactorEnum;
-	      else if (strcmp(name,"MeshElements")==0) return MeshElementsEnum;
-	      else if (strcmp(name,"MeshNumberofelements")==0) return MeshNumberofelementsEnum;
-	      else if (strcmp(name,"MeshNumberoflayers")==0) return MeshNumberoflayersEnum;
-	      else if (strcmp(name,"MeshNumberofvertices")==0) return MeshNumberofverticesEnum;
-	      else if (strcmp(name,"MeshVertexonbase")==0) return MeshVertexonbaseEnum;
-	      else if (strcmp(name,"MeshVertexonsurface")==0) return MeshVertexonsurfaceEnum;
-	      else if (strcmp(name,"MeshVertexonboundary")==0) return MeshVertexonboundaryEnum;
-	      else if (strcmp(name,"MeshElementtype")==0) return MeshElementtypeEnum;
-	      else if (strcmp(name,"DomainType")==0) return DomainTypeEnum;
-	      else if (strcmp(name,"DomainDimension")==0) return DomainDimensionEnum;
-	      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 if (strcmp(name,"Domain3Dsurface")==0) return Domain3DsurfaceEnum;
+	      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,"MasstransportSpcthickness")==0) return MasstransportSpcthicknessEnum;
+	      else if (strcmp(name,"MasstransportRequestedOutputs")==0) return MasstransportRequestedOutputsEnum;
 	      else if (strcmp(name,"MasstransportStabilization")==0) return MasstransportStabilizationEnum;
-	      else if (strcmp(name,"MasstransportNumRequestedOutputs")==0) return MasstransportNumRequestedOutputsEnum;
-	      else if (strcmp(name,"MasstransportRequestedOutputs")==0) return MasstransportRequestedOutputsEnum;
+	      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,"OutputBufferPointer")==0) return OutputBufferPointerEnum;
+	      else if (strcmp(name,"OutputBufferSizePointer")==0) return OutputBufferSizePointerEnum;
+	      else if (strcmp(name,"Outputdefinition")==0) return OutputdefinitionEnum;
+	      else if (strcmp(name,"OutputFileName")==0) return OutputFileNameEnum;
+	      else if (strcmp(name,"OutputFilePointer")==0) return OutputFilePointerEnum;
+	      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,"MassFluxSegments")==0) return MassFluxSegmentsEnum;
-	      else if (strcmp(name,"MassFluxSegmentsPresent")==0) return MassFluxSegmentsPresentEnum;
 	      else if (strcmp(name,"QmuNumberofpartitions")==0) return QmuNumberofpartitionsEnum;
-	      else if (strcmp(name,"QmuNumberofresponses")==0) return QmuNumberofresponsesEnum;
+	      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,"SettingsResultsOnNodes")==0) return SettingsResultsOnNodesEnum;
+	      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,"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,"SealevelriseHElastic")==0) return SealevelriseHElasticEnum;
+	      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,"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,"SettingsLowmem")==0) return SettingsLowmemEnum;
 	      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,"SettingsSolverResidueThreshold")==0) return SettingsSolverResidueThresholdEnum;
 	      else if (strcmp(name,"SettingsWaitonlock")==0) return SettingsWaitonlockEnum;
-	      else if (strcmp(name,"SettingsSolverResidueThreshold")==0) return SettingsSolverResidueThresholdEnum;
-	      else if (strcmp(name,"DebugProfiling")==0) return DebugProfilingEnum;
-	      else if (strcmp(name,"ProfilingCurrentMem")==0) return ProfilingCurrentMemEnum;
-	      else if (strcmp(name,"ProfilingCurrentFlops")==0) return ProfilingCurrentFlopsEnum;
-	      else if (strcmp(name,"ProfilingSolutionTime")==0) return ProfilingSolutionTimeEnum;
+	      else if (strcmp(name,"SmbAdThresh")==0) return SmbAdThreshEnum;
+	      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,"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 stage=3;
+   }
+   if(stage==3){
+	      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,"SmbIsd18opd")==0) return SmbIsd18opdEnum;
+	      else if (strcmp(name,"SmbIsdelta18o")==0) return SmbIsdelta18oEnum;
+	      else if (strcmp(name,"SmbIsdensification")==0) return SmbIsdensificationEnum;
+	      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,"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,"SmbRequestedOutputs")==0) return SmbRequestedOutputsEnum;
+	      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 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,"Surface")==0) return SurfaceEnum;
+	      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 stage=4;
-   }
-   if(stage==4){
-	      if (strcmp(name,"ThermalIsdynamicbasalspc")==0) return ThermalIsdynamicbasalspcEnum;
-	      else if (strcmp(name,"ThermalReltol")==0) return ThermalReltolEnum;
 	      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,"ThermalSpctemperature")==0) return ThermalSpctemperatureEnum;
+	      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,"ThermalNumRequestedOutputs")==0) return ThermalNumRequestedOutputsEnum;
-	      else if (strcmp(name,"ThermalRequestedOutputs")==0) return ThermalRequestedOutputsEnum;
-	      else if (strcmp(name,"GiaMantleViscosity")==0) return GiaMantleViscosityEnum;
-	      else if (strcmp(name,"GiaLithosphereThickness")==0) return GiaLithosphereThicknessEnum;
-	      else if (strcmp(name,"Thickness")==0) return ThicknessEnum;
+	      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,"TimesteppingFinalTime")==0) return TimesteppingFinalTimeEnum;
-	      else if (strcmp(name,"TimesteppingCflCoefficient")==0) return TimesteppingCflCoefficientEnum;
-	      else if (strcmp(name,"TimesteppingTimeAdapt")==0) return TimesteppingTimeAdaptEnum;
 	      else if (strcmp(name,"TimesteppingTimeStep")==0) return TimesteppingTimeStepEnum;
-	      else if (strcmp(name,"TimesteppingInterpForcings")==0) return TimesteppingInterpForcingsEnum;
-	      else if (strcmp(name,"TimesteppingCouplingTime")==0) return TimesteppingCouplingTimeEnum;
-	      else if (strcmp(name,"TransientIssmb")==0) return TransientIssmbEnum;
+	      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,"TransientIsoceancoupling")==0) return TransientIsoceancouplingEnum;
-	      else if (strcmp(name,"TransientIsstressbalance")==0) return TransientIsstressbalanceEnum;
+	      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,"TransientIsthermal")==0) return TransientIsthermalEnum;
-	      else if (strcmp(name,"TransientIsgia")==0) return TransientIsgiaEnum;
-	      else if (strcmp(name,"TransientIsesa")==0) return TransientIsesaEnum;
-	      else if (strcmp(name,"TransientIsdamageevolution")==0) return TransientIsdamageevolutionEnum;
-	      else if (strcmp(name,"TransientIshydrology")==0) return TransientIshydrologyEnum;
 	      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,"BalancethicknessSpcthickness")==0) return BalancethicknessSpcthicknessEnum;
-	      else if (strcmp(name,"BalancethicknessApparentMassbalance")==0) return BalancethicknessApparentMassbalanceEnum;
-	      else if (strcmp(name,"BalancethicknessDiffusionCoefficient")==0) return BalancethicknessDiffusionCoefficientEnum;
+	      else if (strcmp(name,"Velocity")==0) return VelocityEnum;
+	      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,"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,"BalancethicknessOmega0")==0) return BalancethicknessOmega0Enum;
-	      else if (strcmp(name,"BalancethicknessD0")==0) return BalancethicknessD0Enum;
-	      else if (strcmp(name,"Smb")==0) return SmbEnum;
-	      else if (strcmp(name,"SmbAnalysis")==0) return SmbAnalysisEnum;
-	      else if (strcmp(name,"SmbSolution")==0) return SmbSolutionEnum;
-	      else if (strcmp(name,"SmbNumRequestedOutputs")==0) return SmbNumRequestedOutputsEnum;
-	      else if (strcmp(name,"SmbRequestedOutputs")==0) return SmbRequestedOutputsEnum;
-	      else if (strcmp(name,"SmbIsInitialized")==0) return SmbIsInitializedEnum;
-	      else if (strcmp(name,"SmbDzini")==0) return SmbDziniEnum;
+	      else if (strcmp(name,"BalancethicknessThickeningRate")==0) return BalancethicknessThickeningRateEnum;
+	      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,"BasalforcingsPicoBasinId")==0) return BasalforcingsPicoBasinIdEnum;
+	      else if (strcmp(name,"BasalforcingsPicoBoxId")==0) return BasalforcingsPicoBoxIdEnum;
+	      else if (strcmp(name,"BasalforcingsPicoMaxboxcount")==0) return BasalforcingsPicoMaxboxcountEnum;
+	      else if (strcmp(name,"Base")==0) return BaseEnum;
+	      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,"CalvinglevermannCoeff")==0) return CalvinglevermannCoeffEnum;
+	      else if (strcmp(name,"CalvinglevermannMeltingrate")==0) return CalvinglevermannMeltingrateEnum;
+	      else if (strcmp(name,"CalvingMeltingrate")==0) return CalvingMeltingrateEnum;
+	      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,"CalvingStressThresholdFloatingice")==0) return CalvingStressThresholdFloatingiceEnum;
+	      else if (strcmp(name,"CalvingStressThresholdGroundedice")==0) return CalvingStressThresholdGroundediceEnum;
+         else stage=4;
+   }
+   if(stage==4){
+	      if (strcmp(name,"Converged")==0) return ConvergedEnum;
+	      else if (strcmp(name,"CrevasseDepth")==0) return CrevasseDepthEnum;
+	      else if (strcmp(name,"DamageDbar")==0) return DamageDbarEnum;
+	      else if (strcmp(name,"DamageD")==0) return DamageDEnum;
+	      else if (strcmp(name,"DamageF")==0) return DamageFEnum;
+	      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 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,"Enthalpy")==0) return EnthalpyEnum;
+	      else if (strcmp(name,"EnthalpyPicard")==0) return EnthalpyPicardEnum;
+	      else if (strcmp(name,"EplHead")==0) return EplHeadEnum;
+	      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,"EsaDeltathickness")==0) return EsaDeltathicknessEnum;
+	      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,"FrictionAs")==0) return FrictionAsEnum;
+	      else if (strcmp(name,"FrictionC")==0) return FrictionCEnum;
+	      else if (strcmp(name,"FrictionCoefficientcoulomb")==0) return FrictionCoefficientcoulombEnum;
+	      else if (strcmp(name,"FrictionCoefficient")==0) return FrictionCoefficientEnum;
+	      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,"FrictionWaterLayer")==0) return FrictionWaterLayerEnum;
+	      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,"Gradient")==0) return GradientEnum;
+	      else if (strcmp(name,"HydrologyBumpHeight")==0) return HydrologyBumpHeightEnum;
+	      else if (strcmp(name,"HydrologyBumpSpacing")==0) return HydrologyBumpSpacingEnum;
+	      else if (strcmp(name,"HydrologydcBasalMoulinInput")==0) return HydrologydcBasalMoulinInputEnum;
+	      else if (strcmp(name,"HydrologydcEplThickness")==0) return HydrologydcEplThicknessEnum;
+	      else if (strcmp(name,"HydrologydcEplThicknessOld")==0) return HydrologydcEplThicknessOldEnum;
+	      else if (strcmp(name,"HydrologydcMaskEplactiveElt")==0) return HydrologydcMaskEplactiveEltEnum;
+	      else if (strcmp(name,"HydrologydcMaskEplactiveNode")==0) return HydrologydcMaskEplactiveNodeEnum;
+	      else if (strcmp(name,"HydrologydcSedimentTransmitivity")==0) return HydrologydcSedimentTransmitivityEnum;
+	      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,"HydrologyWaterVx")==0) return HydrologyWaterVxEnum;
+	      else if (strcmp(name,"HydrologyWaterVy")==0) return HydrologyWaterVyEnum;
+	      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,"MasstransportSpcthickness")==0) return MasstransportSpcthicknessEnum;
+	      else if (strcmp(name,"MaterialsRheologyBbar")==0) return MaterialsRheologyBbarEnum;
+	      else if (strcmp(name,"MaterialsRheologyB")==0) return MaterialsRheologyBEnum;
+	      else if (strcmp(name,"MaterialsRheologyEbar")==0) return MaterialsRheologyEbarEnum;
+	      else if (strcmp(name,"MaterialsRheologyEcbar")==0) return MaterialsRheologyEcbarEnum;
+	      else if (strcmp(name,"MaterialsRheologyEc")==0) return MaterialsRheologyEcEnum;
+	      else if (strcmp(name,"MaterialsRheologyE")==0) return MaterialsRheologyEEnum;
+	      else if (strcmp(name,"MaterialsRheologyEsbar")==0) return MaterialsRheologyEsbarEnum;
+	      else if (strcmp(name,"MaterialsRheologyEs")==0) return MaterialsRheologyEsEnum;
+	      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,"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,"RheologyBbarAbsGradient")==0) return RheologyBbarAbsGradientEnum;
+	      else if (strcmp(name,"Sealevel")==0) return SealevelEnum;
+	      else if (strcmp(name,"SealevelriseDeltathickness")==0) return SealevelriseDeltathicknessEnum;
+	      else if (strcmp(name,"SedimentHead")==0) return SedimentHeadEnum;
+	      else if (strcmp(name,"SedimentHeadOld")==0) return SedimentHeadOldEnum;
+	      else if (strcmp(name,"SedimentHeadResidual")==0) return SedimentHeadResidualEnum;
+	      else if (strcmp(name,"SigmaNN")==0) return SigmaNNEnum;
+	      else if (strcmp(name,"SmbAccumulation")==0) return SmbAccumulationEnum;
+	      else if (strcmp(name,"SmbA")==0) return SmbAEnum;
+	      else if (strcmp(name,"SmbAini")==0) return SmbAiniEnum;
+	      else if (strcmp(name,"SmbAValue")==0) return SmbAValueEnum;
+	      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,"SmbDini")==0) return SmbDiniEnum;
-	      else if (strcmp(name,"SmbReini")==0) return SmbReiniEnum;
+	      else if (strcmp(name,"SmbDlwrf")==0) return SmbDlwrfEnum;
+	      else if (strcmp(name,"SmbDswrf")==0) return SmbDswrfEnum;
+	      else if (strcmp(name,"SmbDz")==0) return SmbDzEnum;
+         else stage=5;
+   }
+   if(stage==5){
+	      if (strcmp(name,"SmbDzini")==0) return SmbDziniEnum;
+	      else if (strcmp(name,"SmbDzMin")==0) return SmbDzMinEnum;
+	      else if (strcmp(name,"SmbDzTop")==0) return SmbDzTopEnum;
+	      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,"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,"SmbECini")==0) return SmbECiniEnum;
-	      else if (strcmp(name,"SmbWini")==0) return SmbWiniEnum;
-	      else if (strcmp(name,"SmbAini")==0) return SmbAiniEnum;
-	      else if (strcmp(name,"SmbTini")==0) return SmbTiniEnum;
+	      else if (strcmp(name,"SmbHref")==0) return SmbHrefEnum;
+	      else if (strcmp(name,"SmbIsInitialized")==0) return SmbIsInitializedEnum;
+	      else if (strcmp(name,"SmbMassBalance")==0) return SmbMassBalanceEnum;
+	      else if (strcmp(name,"SmbMelt")==0) return SmbMeltEnum;
+	      else if (strcmp(name,"SmbMonthlytemperatures")==0) return SmbMonthlytemperaturesEnum;
+	      else if (strcmp(name,"SmbPAir")==0) return SmbPAirEnum;
+	      else if (strcmp(name,"SmbPddfacIce")==0) return SmbPddfacIceEnum;
+	      else if (strcmp(name,"SmbPddfacSnow")==0) return SmbPddfacSnowEnum;
+	      else if (strcmp(name,"SmbP")==0) return SmbPEnum;
+	      else if (strcmp(name,"SmbPrecipitation")==0) return SmbPrecipitationEnum;
+	      else if (strcmp(name,"SmbPrecipitationsLgm")==0) return SmbPrecipitationsLgmEnum;
+	      else if (strcmp(name,"SmbPrecipitationsPresentday")==0) return SmbPrecipitationsPresentdayEnum;
+	      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,"SmbS0p")==0) return SmbS0pEnum;
+	      else if (strcmp(name,"SmbS0t")==0) return SmbS0tEnum;
 	      else if (strcmp(name,"SmbSizeini")==0) return SmbSizeiniEnum;
-	      else if (strcmp(name,"SMBforcing")==0) return SMBforcingEnum;
-	      else if (strcmp(name,"SmbMassBalance")==0) return SmbMassBalanceEnum;
-	      else if (strcmp(name,"SMBgemb")==0) return SMBgembEnum;
-	      else if (strcmp(name,"SmbInitDensityScaling")==0) return SmbInitDensityScalingEnum;
-	      else if (strcmp(name,"SmbThermoDeltaTScaling")==0) return SmbThermoDeltaTScalingEnum;
-	      else if (strcmp(name,"SmbAdThresh")==0) return SmbAdThreshEnum;
+	      else if (strcmp(name,"SmbSmbref")==0) return SmbSmbrefEnum;
 	      else if (strcmp(name,"SmbTa")==0) return SmbTaEnum;
-	      else if (strcmp(name,"SmbV")==0) return SmbVEnum;
-	      else if (strcmp(name,"SmbDswrf")==0) return SmbDswrfEnum;
-	      else if (strcmp(name,"SmbDlwrf")==0) return SmbDlwrfEnum;
-	      else if (strcmp(name,"SmbP")==0) return SmbPEnum;
-	      else if (strcmp(name,"SmbEAir")==0) return SmbEAirEnum;
-	      else if (strcmp(name,"SmbPAir")==0) return SmbPAirEnum;
+	      else if (strcmp(name,"SmbTemperaturesLgm")==0) return SmbTemperaturesLgmEnum;
+	      else if (strcmp(name,"SmbTemperaturesPresentday")==0) return SmbTemperaturesPresentdayEnum;
+	      else if (strcmp(name,"SmbT")==0) return SmbTEnum;
+	      else if (strcmp(name,"SmbTeValue")==0) return SmbTeValueEnum;
+	      else if (strcmp(name,"SmbTini")==0) return SmbTiniEnum;
 	      else if (strcmp(name,"SmbTmean")==0) return SmbTmeanEnum;
-	      else if (strcmp(name,"SmbC")==0) return SmbCEnum;
 	      else if (strcmp(name,"SmbTz")==0) return SmbTzEnum;
+	      else if (strcmp(name,"SmbV")==0) return SmbVEnum;
 	      else if (strcmp(name,"SmbVz")==0) return SmbVzEnum;
-	      else if (strcmp(name,"SmbDt")==0) return SmbDtEnum;
-	      else if (strcmp(name,"SmbDz")==0) return SmbDzEnum;
-	      else if (strcmp(name,"SmbAIdx")==0) return SmbAIdxEnum;
-	      else if (strcmp(name,"SmbSwIdx")==0) return SmbSwIdxEnum;
-	      else if (strcmp(name,"SmbDenIdx")==0) return SmbDenIdxEnum;
+	      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,"SmbDzTop")==0) return SmbDzTopEnum;
-	      else if (strcmp(name,"SmbDzMin")==0) return SmbDzMinEnum;
 	      else if (strcmp(name,"SmbZY")==0) return SmbZYEnum;
-	      else if (strcmp(name,"SmbZMax")==0) return SmbZMaxEnum;
-	      else if (strcmp(name,"SmbZMin")==0) return SmbZMinEnum;
-	      else if (strcmp(name,"SmbOutputFreq")==0) return SmbOutputFreqEnum;
-	      else if (strcmp(name,"SmbASnow")==0) return SmbASnowEnum;
-	      else if (strcmp(name,"SmbAIce")==0) return SmbAIceEnum;
-	      else if (strcmp(name,"SmbCldFrac")==0) return SmbCldFracEnum;
-	      else if (strcmp(name,"SmbT0wet")==0) return SmbT0wetEnum;
-	      else if (strcmp(name,"SmbT0dry")==0) return SmbT0dryEnum;
-	      else if (strcmp(name,"SmbK")==0) return SmbKEnum;
-	      else if (strcmp(name,"SmbD")==0) return SmbDEnum;
-	      else if (strcmp(name,"SmbRe")==0) return SmbReEnum;
-	      else if (strcmp(name,"SmbGdn")==0) return SmbGdnEnum;
-	      else if (strcmp(name,"SmbGsp")==0) return SmbGspEnum;
-	      else if (strcmp(name,"SmbEC")==0) return SmbECEnum;
-	      else if (strcmp(name,"SmbW")==0) return SmbWEnum;
-	      else if (strcmp(name,"SmbA")==0) return SmbAEnum;
-	      else if (strcmp(name,"SmbT")==0) return SmbTEnum;
-	      else if (strcmp(name,"SmbAValue")==0) return SmbAValueEnum;
-	      else if (strcmp(name,"SmbTeValue")==0) return SmbTeValueEnum;
-	      else if (strcmp(name,"SmbIsgraingrowth")==0) return SmbIsgraingrowthEnum;
-	      else if (strcmp(name,"SmbIsalbedo")==0) return SmbIsalbedoEnum;
-	      else if (strcmp(name,"SmbIsshortwave")==0) return SmbIsshortwaveEnum;
-	      else if (strcmp(name,"SmbIsthermal")==0) return SmbIsthermalEnum;
-	      else if (strcmp(name,"SmbIsaccumulation")==0) return SmbIsaccumulationEnum;
-	      else if (strcmp(name,"SmbIsmelt")==0) return SmbIsmeltEnum;
-	      else if (strcmp(name,"SmbIsdensification")==0) return SmbIsdensificationEnum;
-	      else if (strcmp(name,"SmbIsturbulentflux")==0) return SmbIsturbulentfluxEnum;
-	      else if (strcmp(name,"SmbDzAdd")==0) return SmbDzAddEnum;
-	      else if (strcmp(name,"SmbMAdd")==0) return SmbMAddEnum;
-	      else if (strcmp(name,"SmbFAC")==0) return SmbFACEnum;
-	      else if (strcmp(name,"SMBpdd")==0) return SMBpddEnum;
-	      else if (strcmp(name,"SmbDelta18o")==0) return SmbDelta18oEnum;
-	      else if (strcmp(name,"SmbDelta18oSurface")==0) return SmbDelta18oSurfaceEnum;
-	      else if (strcmp(name,"SmbIsdelta18o")==0) return SmbIsdelta18oEnum;
-	      else if (strcmp(name,"SmbIssetpddfac")==0) return SmbIssetpddfacEnum;
-	      else if (strcmp(name,"SmbIsmungsm")==0) return SmbIsmungsmEnum;
-	      else if (strcmp(name,"SmbIsd18opd")==0) return SmbIsd18opdEnum;
-         else stage=5;
-   }
-   if(stage==5){
-	      if (strcmp(name,"SmbIstemperaturescaled")==0) return SmbIstemperaturescaledEnum;
-	      else if (strcmp(name,"SmbPrecipitationsPresentday")==0) return SmbPrecipitationsPresentdayEnum;
-	      else if (strcmp(name,"SmbPrecipitationsLgm")==0) return SmbPrecipitationsLgmEnum;
-	      else if (strcmp(name,"SmbTemperaturesPresentday")==0) return SmbTemperaturesPresentdayEnum;
-	      else if (strcmp(name,"SmbTemperaturesLgm")==0) return SmbTemperaturesLgmEnum;
-	      else if (strcmp(name,"SmbPrecipitation")==0) return SmbPrecipitationEnum;
-	      else if (strcmp(name,"SmbPddfacSnow")==0) return SmbPddfacSnowEnum;
-	      else if (strcmp(name,"SmbPddfacIce")==0) return SmbPddfacIceEnum;
-	      else if (strcmp(name,"SmbDesfac")==0) return SmbDesfacEnum;
-	      else if (strcmp(name,"SmbS0p")==0) return SmbS0pEnum;
-	      else if (strcmp(name,"SmbS0t")==0) return SmbS0tEnum;
-	      else if (strcmp(name,"SmbRlaps")==0) return SmbRlapsEnum;
-	      else if (strcmp(name,"SmbRlapslgm")==0) return SmbRlapslgmEnum;
-	      else if (strcmp(name,"SmbPfac")==0) return SmbPfacEnum;
-	      else if (strcmp(name,"SmbTdiff")==0) return SmbTdiffEnum;
-	      else if (strcmp(name,"SmbSealev")==0) return SmbSealevEnum;
-	      else if (strcmp(name,"SMBd18opdd")==0) return SMBd18opddEnum;
-	      else if (strcmp(name,"SmbDpermil")==0) return SmbDpermilEnum;
-	      else if (strcmp(name,"SmbF")==0) return SmbFEnum;
-	      else if (strcmp(name,"SMBgradients")==0) return SMBgradientsEnum;
-	      else if (strcmp(name,"SmbMonthlytemperatures")==0) return SmbMonthlytemperaturesEnum;
-	      else if (strcmp(name,"SmbHref")==0) return SmbHrefEnum;
-	      else if (strcmp(name,"SmbSmbref")==0) return SmbSmbrefEnum;
-	      else if (strcmp(name,"SmbBPos")==0) return SmbBPosEnum;
-	      else if (strcmp(name,"SmbBNeg")==0) return SmbBNegEnum;
-	      else if (strcmp(name,"SMBhenning")==0) return SMBhenningEnum;
-	      else if (strcmp(name,"SMBcomponents")==0) return SMBcomponentsEnum;
-	      else if (strcmp(name,"SmbAccumulation")==0) return SmbAccumulationEnum;
-	      else if (strcmp(name,"SmbEvaporation")==0) return SmbEvaporationEnum;
-	      else if (strcmp(name,"SmbRunoff")==0) return SmbRunoffEnum;
-	      else if (strcmp(name,"SMBmeltcomponents")==0) return SMBmeltcomponentsEnum;
-	      else if (strcmp(name,"SmbMelt")==0) return SmbMeltEnum;
-	      else if (strcmp(name,"SmbRefreeze")==0) return SmbRefreezeEnum;
-	      else if (strcmp(name,"SMBgcm")==0) return SMBgcmEnum;
-	      else if (strcmp(name,"SMBgradientsela")==0) return SMBgradientselaEnum;
-	      else if (strcmp(name,"SmbEla")==0) return SmbElaEnum;
-	      else if (strcmp(name,"SmbBMax")==0) return SmbBMaxEnum;
-	      else if (strcmp(name,"SmbBMin")==0) return SmbBMinEnum;
-	      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,"BalancethicknessMisfit")==0) return BalancethicknessMisfitEnum;
-	      else if (strcmp(name,"BedSlopeX")==0) return BedSlopeXEnum;
-	      else if (strcmp(name,"BedSlopeY")==0) return BedSlopeYEnum;
-	      else if (strcmp(name,"Boundary")==0) return BoundaryEnum;
-	      else if (strcmp(name,"Converged")==0) return ConvergedEnum;
-	      else if (strcmp(name,"Internal")==0) return InternalEnum;
-	      else if (strcmp(name,"MassFlux")==0) return MassFluxEnum;
-	      else if (strcmp(name,"MeltingOffset")==0) return MeltingOffsetEnum;
-	      else if (strcmp(name,"Misfit")==0) return MisfitEnum;
-	      else if (strcmp(name,"Pressure")==0) return PressureEnum;
-	      else if (strcmp(name,"AndroidFrictionCoefficient")==0) return AndroidFrictionCoefficientEnum;
-	      else if (strcmp(name,"ResetPenalties")==0) return ResetPenaltiesEnum;
+	      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 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,"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,"TemperaturePicard")==0) return TemperaturePicardEnum;
-	      else if (strcmp(name,"TemperaturePDD")==0) return TemperaturePDDEnum;
+	      else if (strcmp(name,"ThicknessAbsGradient")==0) return ThicknessAbsGradientEnum;
 	      else if (strcmp(name,"ThicknessAbsMisfit")==0) return ThicknessAbsMisfitEnum;
-	      else if (strcmp(name,"SurfaceAbsMisfit")==0) return SurfaceAbsMisfitEnum;
-	      else if (strcmp(name,"OmegaAbsGradient")==0) return OmegaAbsGradientEnum;
-	      else if (strcmp(name,"EtaDiff")==0) return EtaDiffEnum;
-	      else if (strcmp(name,"EtaAbsGradient")==0) return EtaAbsGradientEnum;
+	      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,"Velocity")==0) return VelocityEnum;
 	      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,"VzSSA")==0) return VzSSAEnum;
+	      else if (strcmp(name,"VzFS")==0) return VzFSEnum;
 	      else if (strcmp(name,"VzHO")==0) return VzHOEnum;
-	      else if (strcmp(name,"VzFS")==0) return VzFSEnum;
-	      else if (strcmp(name,"VxMesh")==0) return VxMeshEnum;
-	      else if (strcmp(name,"VyMesh")==0) return VyMeshEnum;
 	      else if (strcmp(name,"VzMesh")==0) return VzMeshEnum;
-	      else if (strcmp(name,"Enthalpy")==0) return EnthalpyEnum;
-	      else if (strcmp(name,"EnthalpyPicard")==0) return EnthalpyPicardEnum;
-	      else if (strcmp(name,"ThicknessAbsGradient")==0) return ThicknessAbsGradientEnum;
-	      else if (strcmp(name,"ThicknessAlongGradient")==0) return ThicknessAlongGradientEnum;
-	      else if (strcmp(name,"ThicknessAcrossGradient")==0) return ThicknessAcrossGradientEnum;
-	      else if (strcmp(name,"ThicknessPositive")==0) return ThicknessPositiveEnum;
-	      else if (strcmp(name,"IntMatParam")==0) return IntMatParamEnum;
-	      else if (strcmp(name,"RheologyBbarAbsGradient")==0) return RheologyBbarAbsGradientEnum;
-	      else if (strcmp(name,"RheologyBAbsGradient")==0) return RheologyBAbsGradientEnum;
-	      else if (strcmp(name,"DragCoefficientAbsGradient")==0) return DragCoefficientAbsGradientEnum;
-	      else if (strcmp(name,"TransientInput")==0) return TransientInputEnum;
-	      else if (strcmp(name,"Waterfraction")==0) return WaterfractionEnum;
+	      else if (strcmp(name,"VzSSA")==0) return VzSSAEnum;
+	      else if (strcmp(name,"Watercolumn")==0) return WatercolumnEnum;
+	      else if (strcmp(name,"WaterColumnOld")==0) return WaterColumnOldEnum;
 	      else if (strcmp(name,"WaterfractionDrainage")==0) return WaterfractionDrainageEnum;
 	      else if (strcmp(name,"WaterfractionDrainageIntegrated")==0) return WaterfractionDrainageIntegratedEnum;
-	      else if (strcmp(name,"Watercolumn")==0) return WatercolumnEnum;
-	      else if (strcmp(name,"ViscousHeating")==0) return ViscousHeatingEnum;
-	      else if (strcmp(name,"HydrologyWaterVx")==0) return HydrologyWaterVxEnum;
-	      else if (strcmp(name,"HydrologyWaterVy")==0) return HydrologyWaterVyEnum;
-	      else if (strcmp(name,"DrivingStressX")==0) return DrivingStressXEnum;
-	      else if (strcmp(name,"DrivingStressY")==0) return DrivingStressYEnum;
-	      else if (strcmp(name,"SigmaNN")==0) return SigmaNNEnum;
-	      else if (strcmp(name,"StressTensor")==0) return StressTensorEnum;
-	      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,"StressMaxPrincipal")==0) return StressMaxPrincipalEnum;
-	      else if (strcmp(name,"DeviatoricStress")==0) return DeviatoricStressEnum;
-	      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,"DeviatoricStresseffective")==0) return DeviatoricStresseffectiveEnum;
+	      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,"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,"Adjointp")==0) return AdjointpEnum;
+	      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,"AutodiffKeep")==0) return AutodiffKeepEnum;
+	      else if (strcmp(name,"Balancethickness2Analysis")==0) return Balancethickness2AnalysisEnum;
+	      else if (strcmp(name,"Balancethickness2Solution")==0) return Balancethickness2SolutionEnum;
          else stage=6;
    }
    if(stage==6){
-	      if (strcmp(name,"LambdaS")==0) return LambdaSEnum;
-	      else if (strcmp(name,"StrainRate")==0) return StrainRateEnum;
-	      else 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;
+	      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,"BasalCrevasse")==0) return BasalCrevasseEnum;
+	      else if (strcmp(name,"BasalforcingsPico")==0) return BasalforcingsPicoEnum;
+	      else if (strcmp(name,"BasalforcingsPicoFarOceantemperature")==0) return BasalforcingsPicoFarOceantemperatureEnum;
+	      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,"Cfsurfacelogvel")==0) return CfsurfacelogvelEnum;
+	      else if (strcmp(name,"Cfsurfacesquare")==0) return CfsurfacesquareEnum;
+	      else if (strcmp(name,"Closed")==0) return ClosedEnum;
+	      else if (strcmp(name,"Colinear")==0) return ColinearEnum;
+	      else if (strcmp(name,"ConstantsG")==0) return ConstantsGEnum;
+	      else if (strcmp(name,"ConstantsReferencetemperature")==0) return ConstantsReferencetemperatureEnum;
+	      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,"ControlSteady")==0) return ControlSteadyEnum;
+	      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,"DamageC4")==0) return DamageC4Enum;
+	      else if (strcmp(name,"DamageElementinterp")==0) return DamageElementinterpEnum;
+	      else if (strcmp(name,"DamageEvolutionAnalysis")==0) return DamageEvolutionAnalysisEnum;
+	      else if (strcmp(name,"DamageEvolutionSolution")==0) return DamageEvolutionSolutionEnum;
+	      else if (strcmp(name,"DamageMaxiter")==0) return DamageMaxiterEnum;
+	      else if (strcmp(name,"DataSet")==0) return DataSetEnum;
+	      else if (strcmp(name,"DatasetInput")==0) return DatasetInputEnum;
+	      else if (strcmp(name,"DataSetParam")==0) return DataSetParamEnum;
+	      else if (strcmp(name,"DefaultAnalysis")==0) return DefaultAnalysisEnum;
+	      else if (strcmp(name,"DefaultCalving")==0) return DefaultCalvingEnum;
+	      else if (strcmp(name,"DegreeOfChannelization")==0) return DegreeOfChannelizationEnum;
+	      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,"DeviatoricStresseffective")==0) return DeviatoricStresseffectiveEnum;
+	      else if (strcmp(name,"DeviatoricStressErrorEstimator")==0) return DeviatoricStressErrorEstimatorEnum;
 	      else if (strcmp(name,"Divergence")==0) return DivergenceEnum;
-	      else if (strcmp(name,"MaxDivergence")==0) return MaxDivergenceEnum;
-	      else if (strcmp(name,"GiaCrossSectionShape")==0) return GiaCrossSectionShapeEnum;
+	      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,"EffectivePressureStacked")==0) return EffectivePressureStackedEnum;
+	      else if (strcmp(name,"EffectivePressureTimeAverage")==0) return EffectivePressureTimeAverageEnum;
+	      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,"EplHeadStacked")==0) return EplHeadStackedEnum;
+	      else if (strcmp(name,"EplHeadTimeAverage")==0) return EplHeadTimeAverageEnum;
+	      else if (strcmp(name,"EsaAnalysis")==0) return EsaAnalysisEnum;
+	      else if (strcmp(name,"EsaEmotion")==0) return EsaEmotionEnum;
+	      else if (strcmp(name,"EsaNmotion")==0) return EsaNmotionEnum;
+	      else if (strcmp(name,"EsaNumRequestedOutputs")==0) return EsaNumRequestedOutputsEnum;
+	      else if (strcmp(name,"EsaRotationrate")==0) return EsaRotationrateEnum;
+	      else if (strcmp(name,"EsaSolution")==0) return EsaSolutionEnum;
+	      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,"EsaTransitions")==0) return EsaTransitionsEnum;
+	      else if (strcmp(name,"EsaUmotion")==0) return EsaUmotionEnum;
+	      else if (strcmp(name,"ExternalResult")==0) return ExternalResultEnum;
+	      else if (strcmp(name,"ExtrapolationAnalysis")==0) return ExtrapolationAnalysisEnum;
+	      else if (strcmp(name,"ExtrudeFromBaseAnalysis")==0) return ExtrudeFromBaseAnalysisEnum;
+	      else if (strcmp(name,"ExtrudeFromTopAnalysis")==0) return ExtrudeFromTopAnalysisEnum;
+	      else if (strcmp(name,"FemModelComm")==0) return FemModelCommEnum;
+	      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,"FlowequationBorderFS")==0) return FlowequationBorderFSEnum;
+	      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,"FSApproximation")==0) return FSApproximationEnum;
+	      else if (strcmp(name,"Fset")==0) return FsetEnum;
+	      else if (strcmp(name,"FSpressure")==0) return FSpressureEnum;
+	      else if (strcmp(name,"FSSolver")==0) return FSSolverEnum;
+	      else if (strcmp(name,"FSvelocity")==0) return FSvelocityEnum;
+	      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,"GiadWdt")==0) return GiadWdtEnum;
+	      else if (strcmp(name,"GiaIvinsAnalysis")==0) return GiaIvinsAnalysisEnum;
+	      else if (strcmp(name,"GiaSolution")==0) return GiaSolutionEnum;
 	      else if (strcmp(name,"GiaW")==0) return GiaWEnum;
-	      else if (strcmp(name,"SaveResults")==0) return SaveResultsEnum;
-	      else if (strcmp(name,"BoolExternalResult")==0) return BoolExternalResultEnum;
-	      else if (strcmp(name,"DoubleExternalResult")==0) return DoubleExternalResultEnum;
-	      else if (strcmp(name,"DoubleMatExternalResult")==0) return DoubleMatExternalResultEnum;
+	      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,"Gset")==0) return GsetEnum;
+	      else if (strcmp(name,"Gsl")==0) return GslEnum;
+	      else if (strcmp(name,"HOApproximation")==0) return HOApproximationEnum;
+         else stage=7;
+   }
+   if(stage==7){
+	      if (strcmp(name,"HOFSApproximation")==0) return HOFSApproximationEnum;
+	      else if (strcmp(name,"Hook")==0) return HookEnum;
+	      else if (strcmp(name,"HydrologyBasalFlux")==0) return HydrologyBasalFluxEnum;
+	      else if (strcmp(name,"HydrologyDCEfficientAnalysis")==0) return HydrologyDCEfficientAnalysisEnum;
+	      else if (strcmp(name,"Hydrologydc")==0) return HydrologydcEnum;
+	      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,"HydrologydcEplThicknessStacked")==0) return HydrologydcEplThicknessStackedEnum;
+	      else if (strcmp(name,"HydrologydcEplThicknessTimeAverage")==0) return HydrologydcEplThicknessTimeAverageEnum;
+	      else if (strcmp(name,"HydrologyDCInefficientAnalysis")==0) return HydrologyDCInefficientAnalysisEnum;
+	      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,"HydrologydcWaterCompressibility")==0) return HydrologydcWaterCompressibilityEnum;
+	      else if (strcmp(name,"HydrologyShreveAnalysis")==0) return HydrologyShreveAnalysisEnum;
+	      else if (strcmp(name,"Hydrologyshreve")==0) return HydrologyshreveEnum;
+	      else if (strcmp(name,"HydrologySolution")==0) return HydrologySolutionEnum;
+	      else if (strcmp(name,"HydrologySommersAnalysis")==0) return HydrologySommersAnalysisEnum;
+	      else if (strcmp(name,"Hydrologysommers")==0) return HydrologysommersEnum;
+	      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,"Incremental")==0) return IncrementalEnum;
+	      else if (strcmp(name,"Indexed")==0) return IndexedEnum;
+	      else if (strcmp(name,"Internal")==0) return InternalEnum;
+	      else if (strcmp(name,"Intersect")==0) return IntersectEnum;
 	      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,"InversionCostFunctionThreshold")==0) return InversionCostFunctionThresholdEnum;
+	      else if (strcmp(name,"InversionFatol")==0) return InversionFatolEnum;
+	      else if (strcmp(name,"InversionFrtol")==0) return InversionFrtolEnum;
+	      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,"LambdaS")==0) return LambdaSEnum;
+	      else if (strcmp(name,"LATaylorHood")==0) return LATaylorHoodEnum;
+	      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,"MantlePlumeGeothermalFlux")==0) return MantlePlumeGeothermalFluxEnum;
+	      else if (strcmp(name,"MaskLandLevelset")==0) return MaskLandLevelsetEnum;
+	      else if (strcmp(name,"MaskOceanLevelset")==0) return MaskOceanLevelsetEnum;
+	      else if (strcmp(name,"Massconaxpby")==0) return MassconaxpbyEnum;
+	      else if (strcmp(name,"Masscon")==0) return MassconEnum;
+	      else if (strcmp(name,"Massfluxatgate")==0) return MassfluxatgateEnum;
+	      else if (strcmp(name,"MassFlux")==0) return MassFluxEnum;
+	      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,"MaterialsBeta")==0) return MaterialsBetaEnum;
+	      else if (strcmp(name,"MaterialsEarthDensity")==0) return MaterialsEarthDensityEnum;
+	      else if (strcmp(name,"Materials")==0) return MaterialsEnum;
+	      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 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,"MaterialsThermalconductivity")==0) return MaterialsThermalconductivityEnum;
+	      else if (strcmp(name,"MaterialsThermalExchangeVelocity")==0) return MaterialsThermalExchangeVelocityEnum;
+	      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,"Matpar")==0) return MatparEnum;
+	      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 if (strcmp(name,"MeshLat")==0) return MeshLatEnum;
+	      else if (strcmp(name,"MeshLong")==0) return MeshLongEnum;
+	      else if (strcmp(name,"MeshNumberofelements")==0) return MeshNumberofelementsEnum;
+	      else if (strcmp(name,"MeshX")==0) return MeshXEnum;
+	      else if (strcmp(name,"MeshY")==0) return MeshYEnum;
+	      else if (strcmp(name,"MINIcondensed")==0) return MINIcondensedEnum;
+	      else if (strcmp(name,"MINI")==0) return MINIEnum;
+	      else if (strcmp(name,"MinVel")==0) return MinVelEnum;
+	      else if (strcmp(name,"MinVx")==0) return MinVxEnum;
+         else stage=8;
+   }
+   if(stage==8){
+	      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,"NewDamage")==0) return NewDamageEnum;
+	      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,"Outputdefinition100")==0) return Outputdefinition100Enum;
+	      else if (strcmp(name,"Outputdefinition1")==0) return Outputdefinition1Enum;
+	      else if (strcmp(name,"P0Array")==0) return P0ArrayEnum;
+	      else if (strcmp(name,"P1bubblecondensed")==0) return P1bubblecondensedEnum;
+	      else if (strcmp(name,"P1bubble")==0) return P1bubbleEnum;
+	      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,"P1xP2")==0) return P1xP2Enum;
+	      else if (strcmp(name,"P1xP3")==0) return P1xP3Enum;
+	      else if (strcmp(name,"P1xP4")==0) return P1xP4Enum;
+	      else if (strcmp(name,"P2bubblecondensed")==0) return P2bubblecondensedEnum;
+	      else if (strcmp(name,"P2bubble")==0) return P2bubbleEnum;
+	      else if (strcmp(name,"P2")==0) return P2Enum;
+	      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,"QmuNumberofresponses")==0) return QmuNumberofresponsesEnum;
+	      else if (strcmp(name,"QmuVariabledescriptors")==0) return QmuVariabledescriptorsEnum;
+	      else if (strcmp(name,"Regionaloutput")==0) return RegionaloutputEnum;
+	      else if (strcmp(name,"Regular")==0) return RegularEnum;
+	      else if (strcmp(name,"ResetPenalties")==0) return ResetPenaltiesEnum;
+	      else if (strcmp(name,"Riftfront")==0) return RiftfrontEnum;
+	      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,"SealevelEustatic")==0) return SealevelEustaticEnum;
+	      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,"SealevelriseAnalysis")==0) return SealevelriseAnalysisEnum;
+	      else if (strcmp(name,"SealevelriseNumRequestedOutputs")==0) return SealevelriseNumRequestedOutputsEnum;
+	      else if (strcmp(name,"SealevelriseSolution")==0) return SealevelriseSolutionEnum;
+	      else if (strcmp(name,"SealevelriseStericRate")==0) return SealevelriseStericRateEnum;
+	      else if (strcmp(name,"SealevelUmotion")==0) return SealevelUmotionEnum;
+	      else if (strcmp(name,"SedimentHeadStacked")==0) return SedimentHeadStackedEnum;
+	      else if (strcmp(name,"SedimentHeadTimeAverage")==0) return SedimentHeadTimeAverageEnum;
+	      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,"SettingsLowmem")==0) return SettingsLowmemEnum;
+	      else if (strcmp(name,"SIAApproximation")==0) return SIAApproximationEnum;
+	      else if (strcmp(name,"SigmaVM")==0) return SigmaVMEnum;
+	      else if (strcmp(name,"SmbAnalysis")==0) return SmbAnalysisEnum;
+	      else if (strcmp(name,"SMBcomponents")==0) return SMBcomponentsEnum;
+	      else if (strcmp(name,"SMBd18opdd")==0) return SMBd18opddEnum;
+	      else if (strcmp(name,"SmbDesfac")==0) return SmbDesfacEnum;
+	      else if (strcmp(name,"SmbDpermil")==0) return SmbDpermilEnum;
+	      else if (strcmp(name,"SmbDzAdd")==0) return SmbDzAddEnum;
+	      else if (strcmp(name,"SmbFAC")==0) return SmbFACEnum;
+	      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,"SMBgradientsela")==0) return SMBgradientselaEnum;
+	      else if (strcmp(name,"SMBgradients")==0) return SMBgradientsEnum;
+	      else if (strcmp(name,"SMBhenning")==0) return SMBhenningEnum;
+	      else if (strcmp(name,"SmbMAdd")==0) return SmbMAddEnum;
+	      else if (strcmp(name,"SMBmeltcomponents")==0) return SMBmeltcomponentsEnum;
+	      else if (strcmp(name,"SmbOutputFreq")==0) return SmbOutputFreqEnum;
+	      else if (strcmp(name,"SMBpdd")==0) return SMBpddEnum;
+	      else if (strcmp(name,"SmbRlaps")==0) return SmbRlapsEnum;
+	      else if (strcmp(name,"SmbRlapslgm")==0) return SmbRlapslgmEnum;
+	      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,"SpcDynamic")==0) return SpcDynamicEnum;
+	      else if (strcmp(name,"SpcStatic")==0) return SpcStaticEnum;
+	      else if (strcmp(name,"SpcTransient")==0) return SpcTransientEnum;
+	      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,"Sset")==0) return SsetEnum;
+	      else if (strcmp(name,"SteadystateSolution")==0) return SteadystateSolutionEnum;
+	      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,"StressIntensityFactor")==0) return StressIntensityFactorEnum;
+	      else if (strcmp(name,"StringArrayParam")==0) return StringArrayParamEnum;
 	      else if (strcmp(name,"StringExternalResult")==0) return StringExternalResultEnum;
-	      else if (strcmp(name,"Step")==0) return StepEnum;
-	      else if (strcmp(name,"Time")==0) return TimeEnum;
-	      else if (strcmp(name,"WaterColumnOld")==0) return WaterColumnOldEnum;
-	      else if (strcmp(name,"SurfaceObservation")==0) return SurfaceObservationEnum;
-	      else if (strcmp(name,"WeightsSurfaceObservation")==0) return WeightsSurfaceObservationEnum;
-	      else if (strcmp(name,"Outputdefinition")==0) return OutputdefinitionEnum;
-	      else if (strcmp(name,"Outputdefinition1")==0) return Outputdefinition1Enum;
-	      else if (strcmp(name,"Outputdefinition2")==0) return Outputdefinition2Enum;
-	      else if (strcmp(name,"Outputdefinition3")==0) return Outputdefinition3Enum;
-	      else if (strcmp(name,"Outputdefinition4")==0) return Outputdefinition4Enum;
-	      else if (strcmp(name,"Outputdefinition5")==0) return Outputdefinition5Enum;
-	      else if (strcmp(name,"Outputdefinition6")==0) return Outputdefinition6Enum;
-	      else if (strcmp(name,"Outputdefinition7")==0) return Outputdefinition7Enum;
-	      else if (strcmp(name,"Outputdefinition8")==0) return Outputdefinition8Enum;
-	      else if (strcmp(name,"Outputdefinition9")==0) return Outputdefinition9Enum;
+	      else if (strcmp(name,"StringParam")==0) return StringParamEnum;
+	      else if (strcmp(name,"SubelementMigration2")==0) return SubelementMigration2Enum;
+	      else if (strcmp(name,"SubelementMigration3")==0) return SubelementMigration3Enum;
+	      else if (strcmp(name,"SubelementMigration")==0) return SubelementMigrationEnum;
+	      else if (strcmp(name,"SurfaceCrevasse")==0) return SurfaceCrevasseEnum;
+	      else if (strcmp(name,"SurfaceSlopeSolution")==0) return SurfaceSlopeSolutionEnum;
+	      else if (strcmp(name,"TaylorHood")==0) return TaylorHoodEnum;
+         else stage=9;
+   }
+   if(stage==9){
+	      if (strcmp(name,"TemperaturePDD")==0) return TemperaturePDDEnum;
+	      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,"ThermalSpctemperature")==0) return ThermalSpctemperatureEnum;
+	      else if (strcmp(name,"ThicknessErrorEstimator")==0) return ThicknessErrorEstimatorEnum;
+	      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 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,"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,"WorldComm")==0) return WorldCommEnum;
+	      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,"Outputdefinition10")==0) return Outputdefinition10Enum;
 	      else if (strcmp(name,"Outputdefinition11")==0) return Outputdefinition11Enum;
 	      else if (strcmp(name,"Outputdefinition12")==0) return Outputdefinition12Enum;
@@ -687,6 +1059,7 @@
 	      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;
@@ -697,6 +1070,7 @@
 	      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;
@@ -707,6 +1081,7 @@
 	      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;
@@ -717,6 +1092,7 @@
 	      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;
@@ -727,6 +1103,7 @@
 	      else if (strcmp(name,"Outputdefinition67")==0) return Outputdefinition67Enum;
 	      else 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;
@@ -737,418 +1114,41 @@
 	      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 stage=10;
+   }
+   if(stage==10){
+	      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 stage=7;
-   }
-   if(stage==7){
-	      if (strcmp(name,"Outputdefinition94")==0) return Outputdefinition94Enum;
+	      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,"Outputdefinition100")==0) return Outputdefinition100Enum;
+	      else if (strcmp(name,"Outputdefinition9")==0) return Outputdefinition9Enum;
 	      else if (strcmp(name,"OutputdefinitionList")==0) return OutputdefinitionListEnum;
-	      else if (strcmp(name,"Massfluxatgate")==0) return MassfluxatgateEnum;
-	      else if (strcmp(name,"Nodalvalue")==0) return NodalvalueEnum;
-	      else if (strcmp(name,"Regionaloutput")==0) return RegionaloutputEnum;
-	      else if (strcmp(name,"VxObs")==0) return VxObsEnum;
-	      else if (strcmp(name,"VyObs")==0) return VyObsEnum;
-	      else if (strcmp(name,"Numberedcostfunction")==0) return NumberedcostfunctionEnum;
-	      else if (strcmp(name,"Cfsurfacesquare")==0) return CfsurfacesquareEnum;
-	      else if (strcmp(name,"Cfsurfacelogvel")==0) return CfsurfacelogvelEnum;
-	      else if (strcmp(name,"Absolute")==0) return AbsoluteEnum;
-	      else if (strcmp(name,"Incremental")==0) return IncrementalEnum;
-	      else if (strcmp(name,"AugmentedLagrangianR")==0) return AugmentedLagrangianREnum;
-	      else if (strcmp(name,"AugmentedLagrangianRhop")==0) return AugmentedLagrangianRhopEnum;
-	      else if (strcmp(name,"AugmentedLagrangianRlambda")==0) return AugmentedLagrangianRlambdaEnum;
-	      else if (strcmp(name,"AugmentedLagrangianRholambda")==0) return AugmentedLagrangianRholambdaEnum;
-	      else if (strcmp(name,"AugmentedLagrangianTheta")==0) return AugmentedLagrangianThetaEnum;
-	      else if (strcmp(name,"None")==0) return NoneEnum;
-	      else if (strcmp(name,"AggressiveMigration")==0) return AggressiveMigrationEnum;
-	      else if (strcmp(name,"SoftMigration")==0) return SoftMigrationEnum;
-	      else if (strcmp(name,"SubelementMigration")==0) return SubelementMigrationEnum;
-	      else if (strcmp(name,"SubelementMigration2")==0) return SubelementMigration2Enum;
-	      else if (strcmp(name,"SubelementMigration3")==0) return SubelementMigration3Enum;
-	      else if (strcmp(name,"SubelementMigration4")==0) return SubelementMigration4Enum;
-	      else if (strcmp(name,"Contact")==0) return ContactEnum;
-	      else if (strcmp(name,"GroundingOnly")==0) return GroundingOnlyEnum;
-	      else if (strcmp(name,"MaskGroundediceLevelset")==0) return MaskGroundediceLevelsetEnum;
-	      else if (strcmp(name,"Adjoint")==0) return AdjointEnum;
-	      else if (strcmp(name,"Colinear")==0) return ColinearEnum;
-	      else if (strcmp(name,"ControlSteady")==0) return ControlSteadyEnum;
-	      else if (strcmp(name,"Fset")==0) return FsetEnum;
-	      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,"Gradient")==0) return GradientEnum;
-	      else if (strcmp(name,"GroundinglineMigration")==0) return GroundinglineMigrationEnum;
-	      else if (strcmp(name,"Gset")==0) return GsetEnum;
-	      else if (strcmp(name,"Index")==0) return IndexEnum;
-	      else if (strcmp(name,"Indexed")==0) return IndexedEnum;
-	      else if (strcmp(name,"Intersect")==0) return IntersectEnum;
-	      else if (strcmp(name,"Nodal")==0) return NodalEnum;
-	      else if (strcmp(name,"OldGradient")==0) return OldGradientEnum;
-	      else if (strcmp(name,"OutputBufferPointer")==0) return OutputBufferPointerEnum;
-	      else if (strcmp(name,"OutputBufferSizePointer")==0) return OutputBufferSizePointerEnum;
-	      else if (strcmp(name,"OutputFilePointer")==0) return OutputFilePointerEnum;
-	      else if (strcmp(name,"ToolkitsFileName")==0) return ToolkitsFileNameEnum;
-	      else if (strcmp(name,"RootPath")==0) return RootPathEnum;
-	      else if (strcmp(name,"OutputFileName")==0) return OutputFileNameEnum;
-	      else if (strcmp(name,"InputFileName")==0) return InputFileNameEnum;
-	      else if (strcmp(name,"LockFileName")==0) return LockFileNameEnum;
-	      else if (strcmp(name,"RestartFileName")==0) return RestartFileNameEnum;
-	      else if (strcmp(name,"ToolkitsTypes")==0) return ToolkitsTypesEnum;
-	      else if (strcmp(name,"ToolkitsOptionsAnalyses")==0) return ToolkitsOptionsAnalysesEnum;
-	      else if (strcmp(name,"ToolkitsOptionsStrings")==0) return ToolkitsOptionsStringsEnum;
-	      else if (strcmp(name,"QmuErrName")==0) return QmuErrNameEnum;
-	      else if (strcmp(name,"QmuInName")==0) return QmuInNameEnum;
-	      else if (strcmp(name,"QmuOutName")==0) return QmuOutNameEnum;
-	      else if (strcmp(name,"Regular")==0) return RegularEnum;
-	      else if (strcmp(name,"Scaled")==0) return ScaledEnum;
-	      else if (strcmp(name,"Separate")==0) return SeparateEnum;
-	      else if (strcmp(name,"Sset")==0) return SsetEnum;
-	      else if (strcmp(name,"Dense")==0) return DenseEnum;
-	      else if (strcmp(name,"MpiDense")==0) return MpiDenseEnum;
-	      else if (strcmp(name,"MpiSparse")==0) return MpiSparseEnum;
-	      else if (strcmp(name,"Seq")==0) return SeqEnum;
-	      else if (strcmp(name,"Mpi")==0) return MpiEnum;
-	      else if (strcmp(name,"Mumps")==0) return MumpsEnum;
-	      else if (strcmp(name,"Gsl")==0) return GslEnum;
-	      else if (strcmp(name,"Cuffey")==0) return CuffeyEnum;
-	      else if (strcmp(name,"BuddJacka")==0) return BuddJackaEnum;
-	      else if (strcmp(name,"CuffeyTemperate")==0) return CuffeyTemperateEnum;
-	      else if (strcmp(name,"Paterson")==0) return PatersonEnum;
-	      else if (strcmp(name,"Arrhenius")==0) return ArrheniusEnum;
-	      else if (strcmp(name,"LliboutryDuval")==0) return LliboutryDuvalEnum;
-	      else if (strcmp(name,"ExtrapolationVariable")==0) return ExtrapolationVariableEnum;
-	      else if (strcmp(name,"IceMaskNodeActivation")==0) return IceMaskNodeActivationEnum;
-	      else if (strcmp(name,"LevelsetfunctionSlopeX")==0) return LevelsetfunctionSlopeXEnum;
-	      else if (strcmp(name,"LevelsetfunctionSlopeY")==0) return LevelsetfunctionSlopeYEnum;
-	      else if (strcmp(name,"LevelsetfunctionPicard")==0) return LevelsetfunctionPicardEnum;
-	      else if (strcmp(name,"LevelsetReinitFrequency")==0) return LevelsetReinitFrequencyEnum;
-	      else if (strcmp(name,"Sealevel")==0) return SealevelEnum;
-	      else if (strcmp(name,"SealevelUmotion")==0) return SealevelUmotionEnum;
-	      else if (strcmp(name,"SealevelNmotion")==0) return SealevelNmotionEnum;
-	      else if (strcmp(name,"SealevelEmotion")==0) return SealevelEmotionEnum;
-	      else if (strcmp(name,"SealevelAbsolute")==0) return SealevelAbsoluteEnum;
-	      else if (strcmp(name,"SealevelEustatic")==0) return SealevelEustaticEnum;
-	      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,"SealevelObs")==0) return SealevelObsEnum;
 	      else if (strcmp(name,"SealevelWeights")==0) return SealevelWeightsEnum;
-	      else if (strcmp(name,"SealevelriseDeltathickness")==0) return SealevelriseDeltathicknessEnum;
-	      else if (strcmp(name,"SealevelriseMaxiter")==0) return SealevelriseMaxiterEnum;
-	      else if (strcmp(name,"SealevelriseReltol")==0) return SealevelriseReltolEnum;
-	      else if (strcmp(name,"SealevelriseAbstol")==0) return SealevelriseAbstolEnum;
-	      else if (strcmp(name,"SealevelriseRigid")==0) return SealevelriseRigidEnum;
-	      else if (strcmp(name,"SealevelriseElastic")==0) return SealevelriseElasticEnum;
-	      else if (strcmp(name,"SealevelriseRotation")==0) return SealevelriseRotationEnum;
-	      else if (strcmp(name,"SealevelriseTidalLoveH")==0) return SealevelriseTidalLoveHEnum;
-	      else if (strcmp(name,"SealevelriseTidalLoveK")==0) return SealevelriseTidalLoveKEnum;
-	      else if (strcmp(name,"SealevelriseFluidLove")==0) return SealevelriseFluidLoveEnum;
-	      else if (strcmp(name,"SealevelriseEquatorialMoi")==0) return SealevelriseEquatorialMoiEnum;
-	      else if (strcmp(name,"SealevelrisePolarMoi")==0) return SealevelrisePolarMoiEnum;
-	      else if (strcmp(name,"SealevelriseAngularVelocity")==0) return SealevelriseAngularVelocityEnum;
-	      else if (strcmp(name,"SealevelriseOceanAreaScaling")==0) return SealevelriseOceanAreaScalingEnum;
-	      else if (strcmp(name,"SealevelriseStericRate")==0) return SealevelriseStericRateEnum;
-	      else if (strcmp(name,"SealevelriseGElastic")==0) return SealevelriseGElasticEnum;
-	      else if (strcmp(name,"SealevelriseUElastic")==0) return SealevelriseUElasticEnum;
-	      else if (strcmp(name,"SealevelriseHElastic")==0) return SealevelriseHElasticEnum;
-	      else if (strcmp(name,"SealevelriseTransitions")==0) return SealevelriseTransitionsEnum;
-	      else if (strcmp(name,"SealevelriseRequestedOutputs")==0) return SealevelriseRequestedOutputsEnum;
-	      else if (strcmp(name,"SealevelriseNumRequestedOutputs")==0) return SealevelriseNumRequestedOutputsEnum;
-	      else if (strcmp(name,"LoveNfreq")==0) return LoveNfreqEnum;
-	      else if (strcmp(name,"LoveFrequencies")==0) return LoveFrequenciesEnum;
-         else stage=8;
-   }
-   if(stage==8){
-	      if (strcmp(name,"LoveShNmax")==0) return LoveShNmaxEnum;
-	      else if (strcmp(name,"LoveShNmin")==0) return LoveShNminEnum;
-	      else if (strcmp(name,"LoveG0")==0) return LoveG0Enum;
-	      else if (strcmp(name,"LoveR0")==0) return LoveR0Enum;
-	      else if (strcmp(name,"LoveMu0")==0) return LoveMu0Enum;
-	      else if (strcmp(name,"LoveAllowLayerDeletion")==0) return LoveAllowLayerDeletionEnum;
-	      else if (strcmp(name,"LoveForcingType")==0) return LoveForcingTypeEnum;
-	      else if (strcmp(name,"LoveHr")==0) return LoveHrEnum;
-	      else if (strcmp(name,"LoveKr")==0) return LoveKrEnum;
-	      else if (strcmp(name,"LoveLr")==0) return LoveLrEnum;
-	      else if (strcmp(name,"LoveHi")==0) return LoveHiEnum;
-	      else if (strcmp(name,"LoveKi")==0) return LoveKiEnum;
-	      else if (strcmp(name,"LoveLi")==0) return LoveLiEnum;
-	      else if (strcmp(name,"LoveKernels")==0) return LoveKernelsEnum;
-	      else if (strcmp(name,"LoveKernelsReal")==0) return LoveKernelsRealEnum;
-	      else if (strcmp(name,"LoveKernelsImag")==0) return LoveKernelsImagEnum;
-	      else if (strcmp(name,"EsaUmotion")==0) return EsaUmotionEnum;
-	      else if (strcmp(name,"EsaNmotion")==0) return EsaNmotionEnum;
-	      else if (strcmp(name,"EsaEmotion")==0) return EsaEmotionEnum;
-	      else if (strcmp(name,"EsaXmotion")==0) return EsaXmotionEnum;
-	      else if (strcmp(name,"EsaYmotion")==0) return EsaYmotionEnum;
-	      else if (strcmp(name,"EsaHemisphere")==0) return EsaHemisphereEnum;
-	      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,"EsaRotationrate")==0) return EsaRotationrateEnum;
-	      else if (strcmp(name,"EsaDeltathickness")==0) return EsaDeltathicknessEnum;
-	      else if (strcmp(name,"EsaUElastic")==0) return EsaUElasticEnum;
-	      else if (strcmp(name,"EsaHElastic")==0) return EsaHElasticEnum;
-	      else if (strcmp(name,"EsaTransitions")==0) return EsaTransitionsEnum;
-	      else if (strcmp(name,"EsaRequestedOutputs")==0) return EsaRequestedOutputsEnum;
-	      else if (strcmp(name,"EsaNumRequestedOutputs")==0) return EsaNumRequestedOutputsEnum;
-	      else if (strcmp(name,"TransientAmrFrequency")==0) return TransientAmrFrequencyEnum;
-	      else if (strcmp(name,"AmrType")==0) return AmrTypeEnum;
-	      else if (strcmp(name,"AmrRestart")==0) return AmrRestartEnum;
-	      else if (strcmp(name,"AmrNeopz")==0) return AmrNeopzEnum;
-	      else if (strcmp(name,"AmrLevelMax")==0) return AmrLevelMaxEnum;
-	      else if (strcmp(name,"AmrLag")==0) return AmrLagEnum;
-	      else if (strcmp(name,"AmrBamg")==0) return AmrBamgEnum;
-	      else if (strcmp(name,"AmrHmin")==0) return AmrHminEnum;
-	      else if (strcmp(name,"AmrHmax")==0) return AmrHmaxEnum;
-	      else if (strcmp(name,"AmrField")==0) return AmrFieldEnum;
-	      else if (strcmp(name,"AmrErr")==0) return AmrErrEnum;
-	      else if (strcmp(name,"AmrKeepMetric")==0) return AmrKeepMetricEnum;
-	      else if (strcmp(name,"AmrGradation")==0) return AmrGradationEnum;
-	      else if (strcmp(name,"AmrGroundingLineResolution")==0) return AmrGroundingLineResolutionEnum;
-	      else if (strcmp(name,"AmrGroundingLineDistance")==0) return AmrGroundingLineDistanceEnum;
-	      else if (strcmp(name,"AmrIceFrontResolution")==0) return AmrIceFrontResolutionEnum;
-	      else if (strcmp(name,"AmrIceFrontDistance")==0) return AmrIceFrontDistanceEnum;
-	      else if (strcmp(name,"AmrThicknessErrorResolution")==0) return AmrThicknessErrorResolutionEnum;
-	      else if (strcmp(name,"AmrThicknessErrorThreshold")==0) return AmrThicknessErrorThresholdEnum;
-	      else if (strcmp(name,"AmrThicknessErrorGroupThreshold")==0) return AmrThicknessErrorGroupThresholdEnum;
-	      else if (strcmp(name,"AmrThicknessErrorMaximum")==0) return AmrThicknessErrorMaximumEnum;
-	      else if (strcmp(name,"AmrDeviatoricErrorResolution")==0) return AmrDeviatoricErrorResolutionEnum;
-	      else if (strcmp(name,"AmrDeviatoricErrorThreshold")==0) return AmrDeviatoricErrorThresholdEnum;
-	      else if (strcmp(name,"AmrDeviatoricErrorGroupThreshold")==0) return AmrDeviatoricErrorGroupThresholdEnum;
-	      else if (strcmp(name,"AmrDeviatoricErrorMaximum")==0) return AmrDeviatoricErrorMaximumEnum;
-	      else if (strcmp(name,"DeviatoricStressErrorEstimator")==0) return DeviatoricStressErrorEstimatorEnum;
-	      else if (strcmp(name,"ThicknessErrorEstimator")==0) return ThicknessErrorEstimatorEnum;
-	      else if (strcmp(name,"ParametersEND")==0) return ParametersENDEnum;
-	      else if (strcmp(name,"Approximation")==0) return ApproximationEnum;
-	      else if (strcmp(name,"NoneApproximation")==0) return NoneApproximationEnum;
-	      else if (strcmp(name,"SIAApproximation")==0) return SIAApproximationEnum;
-	      else if (strcmp(name,"SSAApproximation")==0) return SSAApproximationEnum;
-	      else if (strcmp(name,"SSAHOApproximation")==0) return SSAHOApproximationEnum;
-	      else if (strcmp(name,"SSAFSApproximation")==0) return SSAFSApproximationEnum;
-	      else if (strcmp(name,"L1L2Approximation")==0) return L1L2ApproximationEnum;
-	      else if (strcmp(name,"HOApproximation")==0) return HOApproximationEnum;
-	      else if (strcmp(name,"HOFSApproximation")==0) return HOFSApproximationEnum;
-	      else if (strcmp(name,"FSApproximation")==0) return FSApproximationEnum;
-	      else if (strcmp(name,"FSvelocity")==0) return FSvelocityEnum;
-	      else if (strcmp(name,"FSpressure")==0) return FSpressureEnum;
-	      else if (strcmp(name,"InputsEND")==0) return InputsENDEnum;
-	      else if (strcmp(name,"XY")==0) return XYEnum;
-	      else if (strcmp(name,"XYZ")==0) return XYZEnum;
-	      else if (strcmp(name,"GenericParam")==0) return GenericParamEnum;
-	      else if (strcmp(name,"BoolInput")==0) return BoolInputEnum;
-	      else if (strcmp(name,"BoolParam")==0) return BoolParamEnum;
-	      else if (strcmp(name,"Contour")==0) return ContourEnum;
-	      else if (strcmp(name,"ControlInput")==0) return ControlInputEnum;
-	      else if (strcmp(name,"DatasetInput")==0) return DatasetInputEnum;
-	      else if (strcmp(name,"DoubleInput")==0) return DoubleInputEnum;
-	      else if (strcmp(name,"DoubleArrayInput")==0) return DoubleArrayInputEnum;
-	      else if (strcmp(name,"DataSetParam")==0) return DataSetParamEnum;
-	      else if (strcmp(name,"DoubleMatArrayParam")==0) return DoubleMatArrayParamEnum;
-	      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,"Hook")==0) return HookEnum;
-	      else if (strcmp(name,"ExternalResult")==0) return ExternalResultEnum;
-	      else if (strcmp(name,"FileParam")==0) return FileParamEnum;
-	      else if (strcmp(name,"Input")==0) return InputEnum;
-	      else if (strcmp(name,"IntInput")==0) return IntInputEnum;
-	      else if (strcmp(name,"IntParam")==0) return IntParamEnum;
-	      else if (strcmp(name,"IntVecParam")==0) return IntVecParamEnum;
-	      else if (strcmp(name,"TransientParam")==0) return TransientParamEnum;
-	      else if (strcmp(name,"TransientArrayParam")==0) return TransientArrayParamEnum;
-	      else if (strcmp(name,"Matice")==0) return MaticeEnum;
-	      else if (strcmp(name,"Matlitho")==0) return MatlithoEnum;
-	      else if (strcmp(name,"Matdamageice")==0) return MatdamageiceEnum;
-	      else if (strcmp(name,"Matenhancedice")==0) return MatenhancediceEnum;
-	      else if (strcmp(name,"Matestar")==0) return MatestarEnum;
-	      else if (strcmp(name,"Matpar")==0) return MatparEnum;
-	      else if (strcmp(name,"Node")==0) return NodeEnum;
-	      else if (strcmp(name,"Numericalflux")==0) return NumericalfluxEnum;
-	      else if (strcmp(name,"Neumannflux")==0) return NeumannfluxEnum;
-	      else if (strcmp(name,"Param")==0) return ParamEnum;
-	      else if (strcmp(name,"Moulin")==0) return MoulinEnum;
-	      else if (strcmp(name,"Pengrid")==0) return PengridEnum;
-	      else if (strcmp(name,"Penpair")==0) return PenpairEnum;
-	      else if (strcmp(name,"Profiler")==0) return ProfilerEnum;
-	      else if (strcmp(name,"MatrixParam")==0) return MatrixParamEnum;
-	      else if (strcmp(name,"Masscon")==0) return MassconEnum;
-	      else if (strcmp(name,"Massconaxpby")==0) return MassconaxpbyEnum;
-	      else if (strcmp(name,"NodeSId")==0) return NodeSIdEnum;
-	      else if (strcmp(name,"ElementSId")==0) return ElementSIdEnum;
-	      else if (strcmp(name,"VectorParam")==0) return VectorParamEnum;
-	      else if (strcmp(name,"Riftfront")==0) return RiftfrontEnum;
-         else stage=9;
-   }
-   if(stage==9){
-	      if (strcmp(name,"Segment")==0) return SegmentEnum;
-	      else if (strcmp(name,"SegmentRiftfront")==0) return SegmentRiftfrontEnum;
-	      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,"StringArrayParam")==0) return StringArrayParamEnum;
-	      else if (strcmp(name,"StringParam")==0) return StringParamEnum;
-	      else if (strcmp(name,"Seg")==0) return SegEnum;
-	      else if (strcmp(name,"SegInput")==0) return SegInputEnum;
-	      else if (strcmp(name,"Tria")==0) return TriaEnum;
-	      else if (strcmp(name,"TriaInput")==0) return TriaInputEnum;
-	      else if (strcmp(name,"Tetra")==0) return TetraEnum;
-	      else if (strcmp(name,"TetraInput")==0) return TetraInputEnum;
-	      else if (strcmp(name,"Penta")==0) return PentaEnum;
-	      else if (strcmp(name,"PentaInput")==0) return PentaInputEnum;
-	      else if (strcmp(name,"Vertex")==0) return VertexEnum;
-	      else if (strcmp(name,"VertexPId")==0) return VertexPIdEnum;
-	      else if (strcmp(name,"VertexSId")==0) return VertexSIdEnum;
-	      else if (strcmp(name,"Option")==0) return OptionEnum;
-	      else if (strcmp(name,"GenericOption")==0) return GenericOptionEnum;
-	      else if (strcmp(name,"AdjointBalancethicknessAnalysis")==0) return AdjointBalancethicknessAnalysisEnum;
-	      else if (strcmp(name,"AdjointBalancethickness2Analysis")==0) return AdjointBalancethickness2AnalysisEnum;
-	      else if (strcmp(name,"AdjointHorizAnalysis")==0) return AdjointHorizAnalysisEnum;
-	      else if (strcmp(name,"DefaultAnalysis")==0) return DefaultAnalysisEnum;
-	      else if (strcmp(name,"BalancethicknessAnalysis")==0) return BalancethicknessAnalysisEnum;
-	      else if (strcmp(name,"BalancethicknessSolution")==0) return BalancethicknessSolutionEnum;
-	      else if (strcmp(name,"Balancethickness2Analysis")==0) return Balancethickness2AnalysisEnum;
-	      else if (strcmp(name,"Balancethickness2Solution")==0) return Balancethickness2SolutionEnum;
-	      else if (strcmp(name,"BalancethicknessSoftAnalysis")==0) return BalancethicknessSoftAnalysisEnum;
-	      else if (strcmp(name,"BalancethicknessSoftSolution")==0) return BalancethicknessSoftSolutionEnum;
-	      else if (strcmp(name,"BalancevelocityAnalysis")==0) return BalancevelocityAnalysisEnum;
-	      else if (strcmp(name,"BalancevelocitySolution")==0) return BalancevelocitySolutionEnum;
-	      else if (strcmp(name,"L2ProjectionEPLAnalysis")==0) return L2ProjectionEPLAnalysisEnum;
-	      else if (strcmp(name,"L2ProjectionBaseAnalysis")==0) return L2ProjectionBaseAnalysisEnum;
-	      else if (strcmp(name,"BedSlopeSolution")==0) return BedSlopeSolutionEnum;
-	      else if (strcmp(name,"DamageEvolutionSolution")==0) return DamageEvolutionSolutionEnum;
-	      else if (strcmp(name,"DamageEvolutionAnalysis")==0) return DamageEvolutionAnalysisEnum;
-	      else if (strcmp(name,"StressbalanceAnalysis")==0) return StressbalanceAnalysisEnum;
-	      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,"EnthalpyAnalysis")==0) return EnthalpyAnalysisEnum;
-	      else if (strcmp(name,"HydrologyShreveAnalysis")==0) return HydrologyShreveAnalysisEnum;
-	      else if (strcmp(name,"HydrologyDCInefficientAnalysis")==0) return HydrologyDCInefficientAnalysisEnum;
-	      else if (strcmp(name,"HydrologyDCEfficientAnalysis")==0) return HydrologyDCEfficientAnalysisEnum;
-	      else if (strcmp(name,"HydrologySommersAnalysis")==0) return HydrologySommersAnalysisEnum;
-	      else if (strcmp(name,"HydrologySolution")==0) return HydrologySolutionEnum;
-	      else if (strcmp(name,"MeltingAnalysis")==0) return MeltingAnalysisEnum;
-	      else if (strcmp(name,"MasstransportAnalysis")==0) return MasstransportAnalysisEnum;
-	      else if (strcmp(name,"MasstransportSolution")==0) return MasstransportSolutionEnum;
-	      else if (strcmp(name,"FreeSurfaceBaseAnalysis")==0) return FreeSurfaceBaseAnalysisEnum;
-	      else if (strcmp(name,"FreeSurfaceTopAnalysis")==0) return FreeSurfaceTopAnalysisEnum;
-	      else if (strcmp(name,"ExtrudeFromBaseAnalysis")==0) return ExtrudeFromBaseAnalysisEnum;
-	      else if (strcmp(name,"ExtrudeFromTopAnalysis")==0) return ExtrudeFromTopAnalysisEnum;
-	      else if (strcmp(name,"DepthAverageAnalysis")==0) return DepthAverageAnalysisEnum;
-	      else if (strcmp(name,"SealevelriseSolution")==0) return SealevelriseSolutionEnum;
-	      else if (strcmp(name,"SealevelriseAnalysis")==0) return SealevelriseAnalysisEnum;
-	      else if (strcmp(name,"SteadystateSolution")==0) return SteadystateSolutionEnum;
-	      else if (strcmp(name,"SurfaceSlopeSolution")==0) return SurfaceSlopeSolutionEnum;
-	      else if (strcmp(name,"SmoothAnalysis")==0) return SmoothAnalysisEnum;
-	      else if (strcmp(name,"ThermalAnalysis")==0) return ThermalAnalysisEnum;
-	      else if (strcmp(name,"ThermalSolution")==0) return ThermalSolutionEnum;
-	      else if (strcmp(name,"TransientSolution")==0) return TransientSolutionEnum;
-	      else if (strcmp(name,"UzawaPressureAnalysis")==0) return UzawaPressureAnalysisEnum;
-	      else if (strcmp(name,"GiaSolution")==0) return GiaSolutionEnum;
-	      else if (strcmp(name,"GiaIvinsAnalysis")==0) return GiaIvinsAnalysisEnum;
-	      else if (strcmp(name,"EsaSolution")==0) return EsaSolutionEnum;
-	      else if (strcmp(name,"EsaAnalysis")==0) return EsaAnalysisEnum;
-	      else if (strcmp(name,"LoveSolution")==0) return LoveSolutionEnum;
-	      else if (strcmp(name,"LoveAnalysis")==0) return LoveAnalysisEnum;
-	      else if (strcmp(name,"LevelsetAnalysis")==0) return LevelsetAnalysisEnum;
-	      else if (strcmp(name,"ExtrapolationAnalysis")==0) return ExtrapolationAnalysisEnum;
-	      else if (strcmp(name,"GaussSeg")==0) return GaussSegEnum;
-	      else if (strcmp(name,"GaussTria")==0) return GaussTriaEnum;
-	      else if (strcmp(name,"GaussTetra")==0) return GaussTetraEnum;
-	      else if (strcmp(name,"GaussPenta")==0) return GaussPentaEnum;
+	      else if (strcmp(name,"StrainRate")==0) return StrainRateEnum;
+	      else if (strcmp(name,"StressbalanceViscosityOvershoot")==0) return StressbalanceViscosityOvershootEnum;
+	      else if (strcmp(name,"StressTensor")==0) return StressTensorEnum;
+	      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,"BilinearInterp")==0) return BilinearInterpEnum;
-	      else if (strcmp(name,"NearestInterp")==0) return NearestInterpEnum;
-	      else if (strcmp(name,"MinVel")==0) return MinVelEnum;
-	      else if (strcmp(name,"MaxVel")==0) return MaxVelEnum;
-	      else if (strcmp(name,"MinVx")==0) return MinVxEnum;
-	      else if (strcmp(name,"MaxVx")==0) return MaxVxEnum;
-	      else if (strcmp(name,"MaxAbsVx")==0) return MaxAbsVxEnum;
-	      else if (strcmp(name,"MinVy")==0) return MinVyEnum;
-	      else if (strcmp(name,"MaxVy")==0) return MaxVyEnum;
-	      else if (strcmp(name,"MaxAbsVy")==0) return MaxAbsVyEnum;
-	      else if (strcmp(name,"MinVz")==0) return MinVzEnum;
-	      else if (strcmp(name,"MaxVz")==0) return MaxVzEnum;
-	      else if (strcmp(name,"MaxAbsVz")==0) return MaxAbsVzEnum;
-	      else if (strcmp(name,"FloatingArea")==0) return FloatingAreaEnum;
-	      else if (strcmp(name,"FloatingAreaScaled")==0) return FloatingAreaScaledEnum;
-	      else if (strcmp(name,"GroundedArea")==0) return GroundedAreaEnum;
-	      else if (strcmp(name,"GroundedAreaScaled")==0) return GroundedAreaScaledEnum;
-	      else if (strcmp(name,"IceMass")==0) return IceMassEnum;
-	      else if (strcmp(name,"IceMassScaled")==0) return IceMassScaledEnum;
-	      else if (strcmp(name,"IceVolume")==0) return IceVolumeEnum;
-	      else if (strcmp(name,"IceVolumeScaled")==0) return IceVolumeScaledEnum;
-	      else if (strcmp(name,"IceVolumeAboveFloatation")==0) return IceVolumeAboveFloatationEnum;
-	      else if (strcmp(name,"IceVolumeAboveFloatationScaled")==0) return IceVolumeAboveFloatationScaledEnum;
-	      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 if (strcmp(name,"TotalSmb")==0) return TotalSmbEnum;
-	      else if (strcmp(name,"TotalSmbScaled")==0) return TotalSmbScaledEnum;
-	      else if (strcmp(name,"P0")==0) return P0Enum;
-	      else if (strcmp(name,"P0Array")==0) return P0ArrayEnum;
-	      else if (strcmp(name,"P1")==0) return P1Enum;
-	      else if (strcmp(name,"P1DG")==0) return P1DGEnum;
-	      else if (strcmp(name,"P1bubble")==0) return P1bubbleEnum;
-	      else if (strcmp(name,"P1bubblecondensed")==0) return P1bubblecondensedEnum;
-	      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,"P1xP2")==0) return P1xP2Enum;
-	      else if (strcmp(name,"P1xP3")==0) return P1xP3Enum;
-	      else if (strcmp(name,"P1xP4")==0) return P1xP4Enum;
-	      else if (strcmp(name,"P2xP4")==0) return P2xP4Enum;
-         else stage=10;
-   }
-   if(stage==10){
-	      if (strcmp(name,"P1P1")==0) return P1P1Enum;
-	      else if (strcmp(name,"P1P1GLS")==0) return P1P1GLSEnum;
-	      else if (strcmp(name,"MINI")==0) return MINIEnum;
-	      else if (strcmp(name,"MINIcondensed")==0) return MINIcondensedEnum;
-	      else if (strcmp(name,"TaylorHood")==0) return TaylorHoodEnum;
-	      else if (strcmp(name,"LATaylorHood")==0) return LATaylorHoodEnum;
-	      else if (strcmp(name,"XTaylorHood")==0) return XTaylorHoodEnum;
-	      else if (strcmp(name,"OneLayerP4z")==0) return OneLayerP4zEnum;
-	      else if (strcmp(name,"CrouzeixRaviart")==0) return CrouzeixRaviartEnum;
-	      else if (strcmp(name,"LACrouzeixRaviart")==0) return LACrouzeixRaviartEnum;
-	      else if (strcmp(name,"Closed")==0) return ClosedEnum;
-	      else if (strcmp(name,"Free")==0) return FreeEnum;
-	      else if (strcmp(name,"Open")==0) return OpenEnum;
-	      else if (strcmp(name,"Air")==0) return AirEnum;
-	      else if (strcmp(name,"Ice")==0) return IceEnum;
-	      else if (strcmp(name,"Melange")==0) return MelangeEnum;
-	      else if (strcmp(name,"Water")==0) return WaterEnum;
-	      else if (strcmp(name,"DataSet")==0) return DataSetEnum;
-	      else if (strcmp(name,"Constraints")==0) return ConstraintsEnum;
-	      else if (strcmp(name,"Loads")==0) return LoadsEnum;
-	      else if (strcmp(name,"Materials")==0) return MaterialsEnum;
-	      else if (strcmp(name,"Nodes")==0) return NodesEnum;
-	      else if (strcmp(name,"Contours")==0) return ContoursEnum;
-	      else if (strcmp(name,"Parameters")==0) return ParametersEnum;
-	      else if (strcmp(name,"Vertices")==0) return VerticesEnum;
-	      else if (strcmp(name,"Results")==0) return ResultsEnum;
 	      else if (strcmp(name,"MaximumNumberOfDefinitions")==0) return MaximumNumberOfDefinitionsEnum;
          else stage=11;
    }