from StringToEnum import StringToEnum

"""

   WARNING: DO NOT MODIFY THIS FILE
            this file has been automatically generated by src/c/EnumDefinitions/Synchronize.sh
            Please read src/c/EnumDefinitions/README for more information

"""

def AutodiffIsautodiffEnum():
	"""
	AUTODIFFISAUTODIFFENUM - Enum of AutodiffIsautodiff

	   Usage:
	      macro=AutodiffIsautodiffEnum()
	"""

	return StringToEnum('AutodiffIsautodiff')[0]

def AutodiffNumDependentsEnum():
	"""
	AUTODIFFNUMDEPENDENTSENUM - Enum of AutodiffNumDependents

	   Usage:
	      macro=AutodiffNumDependentsEnum()
	"""

	return StringToEnum('AutodiffNumDependents')[0]

def AutodiffNumDependentObjectsEnum():
	"""
	AUTODIFFNUMDEPENDENTOBJECTSENUM - Enum of AutodiffNumDependentObjects

	   Usage:
	      macro=AutodiffNumDependentObjectsEnum()
	"""

	return StringToEnum('AutodiffNumDependentObjects')[0]

def AutodiffDependentObjectNamesEnum():
	"""
	AUTODIFFDEPENDENTOBJECTNAMESENUM - Enum of AutodiffDependentObjectNames

	   Usage:
	      macro=AutodiffDependentObjectNamesEnum()
	"""

	return StringToEnum('AutodiffDependentObjectNames')[0]

def AutodiffDependentObjectTypesEnum():
	"""
	AUTODIFFDEPENDENTOBJECTTYPESENUM - Enum of AutodiffDependentObjectTypes

	   Usage:
	      macro=AutodiffDependentObjectTypesEnum()
	"""

	return StringToEnum('AutodiffDependentObjectTypes')[0]

def AutodiffDependentObjectIndicesEnum():
	"""
	AUTODIFFDEPENDENTOBJECTINDICESENUM - Enum of AutodiffDependentObjectIndices

	   Usage:
	      macro=AutodiffDependentObjectIndicesEnum()
	"""

	return StringToEnum('AutodiffDependentObjectIndices')[0]

def AutodiffDependentObjectsEnum():
	"""
	AUTODIFFDEPENDENTOBJECTSENUM - Enum of AutodiffDependentObjects

	   Usage:
	      macro=AutodiffDependentObjectsEnum()
	"""

	return StringToEnum('AutodiffDependentObjects')[0]

def AutodiffNumIndependentsEnum():
	"""
	AUTODIFFNUMINDEPENDENTSENUM - Enum of AutodiffNumIndependents

	   Usage:
	      macro=AutodiffNumIndependentsEnum()
	"""

	return StringToEnum('AutodiffNumIndependents')[0]

def AutodiffNumIndependentObjectsEnum():
	"""
	AUTODIFFNUMINDEPENDENTOBJECTSENUM - Enum of AutodiffNumIndependentObjects

	   Usage:
	      macro=AutodiffNumIndependentObjectsEnum()
	"""

	return StringToEnum('AutodiffNumIndependentObjects')[0]

def AutodiffIndependentObjectNamesEnum():
	"""
	AUTODIFFINDEPENDENTOBJECTNAMESENUM - Enum of AutodiffIndependentObjectNames

	   Usage:
	      macro=AutodiffIndependentObjectNamesEnum()
	"""

	return StringToEnum('AutodiffIndependentObjectNames')[0]

def AutodiffIndependentObjectTypesEnum():
	"""
	AUTODIFFINDEPENDENTOBJECTTYPESENUM - Enum of AutodiffIndependentObjectTypes

	   Usage:
	      macro=AutodiffIndependentObjectTypesEnum()
	"""

	return StringToEnum('AutodiffIndependentObjectTypes')[0]

def AutodiffIndependentObjectsEnum():
	"""
	AUTODIFFINDEPENDENTOBJECTSENUM - Enum of AutodiffIndependentObjects

	   Usage:
	      macro=AutodiffIndependentObjectsEnum()
	"""

	return StringToEnum('AutodiffIndependentObjects')[0]

def AutodiffJacobianEnum():
	"""
	AUTODIFFJACOBIANENUM - Enum of AutodiffJacobian

	   Usage:
	      macro=AutodiffJacobianEnum()
	"""

	return StringToEnum('AutodiffJacobian')[0]

def AutodiffXpEnum():
	"""
	AUTODIFFXPENUM - Enum of AutodiffXp

	   Usage:
	      macro=AutodiffXpEnum()
	"""

	return StringToEnum('AutodiffXp')[0]

def AutodiffDriverEnum():
	"""
	AUTODIFFDRIVERENUM - Enum of AutodiffDriver

	   Usage:
	      macro=AutodiffDriverEnum()
	"""

	return StringToEnum('AutodiffDriver')[0]

def AutodiffFosForwardIndexEnum():
	"""
	AUTODIFFFOSFORWARDINDEXENUM - Enum of AutodiffFosForwardIndex

	   Usage:
	      macro=AutodiffFosForwardIndexEnum()
	"""

	return StringToEnum('AutodiffFosForwardIndex')[0]

def AutodiffFovForwardIndicesEnum():
	"""
	AUTODIFFFOVFORWARDINDICESENUM - Enum of AutodiffFovForwardIndices

	   Usage:
	      macro=AutodiffFovForwardIndicesEnum()
	"""

	return StringToEnum('AutodiffFovForwardIndices')[0]

def AutodiffFosReverseIndexEnum():
	"""
	AUTODIFFFOSREVERSEINDEXENUM - Enum of AutodiffFosReverseIndex

	   Usage:
	      macro=AutodiffFosReverseIndexEnum()
	"""

	return StringToEnum('AutodiffFosReverseIndex')[0]

def AutodiffMassFluxSegmentsPresentEnum():
	"""
	AUTODIFFMASSFLUXSEGMENTSPRESENTENUM - Enum of AutodiffMassFluxSegmentsPresent

	   Usage:
	      macro=AutodiffMassFluxSegmentsPresentEnum()
	"""

	return StringToEnum('AutodiffMassFluxSegmentsPresent')[0]

def AutodiffKeepEnum():
	"""
	AUTODIFFKEEPENUM - Enum of AutodiffKeep

	   Usage:
	      macro=AutodiffKeepEnum()
	"""

	return StringToEnum('AutodiffKeep')[0]

def BalancethicknessSpcthicknessEnum():
	"""
	BALANCETHICKNESSSPCTHICKNESSENUM - Enum of BalancethicknessSpcthickness

	   Usage:
	      macro=BalancethicknessSpcthicknessEnum()
	"""

	return StringToEnum('BalancethicknessSpcthickness')[0]

def BalancethicknessStabilizationEnum():
	"""
	BALANCETHICKNESSSTABILIZATIONENUM - Enum of BalancethicknessStabilization

	   Usage:
	      macro=BalancethicknessStabilizationEnum()
	"""

	return StringToEnum('BalancethicknessStabilization')[0]

def BalancethicknessThickeningRateEnum():
	"""
	BALANCETHICKNESSTHICKENINGRATEENUM - Enum of BalancethicknessThickeningRate

	   Usage:
	      macro=BalancethicknessThickeningRateEnum()
	"""

	return StringToEnum('BalancethicknessThickeningRate')[0]

def BasalforcingsGeothermalfluxEnum():
	"""
	BASALFORCINGSGEOTHERMALFLUXENUM - Enum of BasalforcingsGeothermalflux

	   Usage:
	      macro=BasalforcingsGeothermalfluxEnum()
	"""

	return StringToEnum('BasalforcingsGeothermalflux')[0]

def BasalforcingsMeltingRateCorrectionEnum():
	"""
	BASALFORCINGSMELTINGRATECORRECTIONENUM - Enum of BasalforcingsMeltingRateCorrection

	   Usage:
	      macro=BasalforcingsMeltingRateCorrectionEnum()
	"""

	return StringToEnum('BasalforcingsMeltingRateCorrection')[0]

def BasalforcingsMeltingRateEnum():
	"""
	BASALFORCINGSMELTINGRATEENUM - Enum of BasalforcingsMeltingRate

	   Usage:
	      macro=BasalforcingsMeltingRateEnum()
	"""

	return StringToEnum('BasalforcingsMeltingRate')[0]

def BathymetryEnum():
	"""
	BATHYMETRYENUM - Enum of Bathymetry

	   Usage:
	      macro=BathymetryEnum()
	"""

	return StringToEnum('Bathymetry')[0]

def BedEnum():
	"""
	BEDENUM - Enum of Bed

	   Usage:
	      macro=BedEnum()
	"""

	return StringToEnum('Bed')[0]

def ConstantsGEnum():
	"""
	CONSTANTSGENUM - Enum of ConstantsG

	   Usage:
	      macro=ConstantsGEnum()
	"""

	return StringToEnum('ConstantsG')[0]

def ConstantsReferencetemperatureEnum():
	"""
	CONSTANTSREFERENCETEMPERATUREENUM - Enum of ConstantsReferencetemperature

	   Usage:
	      macro=ConstantsReferencetemperatureEnum()
	"""

	return StringToEnum('ConstantsReferencetemperature')[0]

def ConstantsYtsEnum():
	"""
	CONSTANTSYTSENUM - Enum of ConstantsYts

	   Usage:
	      macro=ConstantsYtsEnum()
	"""

	return StringToEnum('ConstantsYts')[0]

def DependentObjectEnum():
	"""
	DEPENDENTOBJECTENUM - Enum of DependentObject

	   Usage:
	      macro=DependentObjectEnum()
	"""

	return StringToEnum('DependentObject')[0]

def DiagnosticAbstolEnum():
	"""
	DIAGNOSTICABSTOLENUM - Enum of DiagnosticAbstol

	   Usage:
	      macro=DiagnosticAbstolEnum()
	"""

	return StringToEnum('DiagnosticAbstol')[0]

def DiagnosticIcefrontEnum():
	"""
	DIAGNOSTICICEFRONTENUM - Enum of DiagnosticIcefront

	   Usage:
	      macro=DiagnosticIcefrontEnum()
	"""

	return StringToEnum('DiagnosticIcefront')[0]

def DiagnosticIsnewtonEnum():
	"""
	DIAGNOSTICISNEWTONENUM - Enum of DiagnosticIsnewton

	   Usage:
	      macro=DiagnosticIsnewtonEnum()
	"""

	return StringToEnum('DiagnosticIsnewton')[0]

def DiagnosticMaxiterEnum():
	"""
	DIAGNOSTICMAXITERENUM - Enum of DiagnosticMaxiter

	   Usage:
	      macro=DiagnosticMaxiterEnum()
	"""

	return StringToEnum('DiagnosticMaxiter')[0]

def DiagnosticNumRequestedOutputsEnum():
	"""
	DIAGNOSTICNUMREQUESTEDOUTPUTSENUM - Enum of DiagnosticNumRequestedOutputs

	   Usage:
	      macro=DiagnosticNumRequestedOutputsEnum()
	"""

	return StringToEnum('DiagnosticNumRequestedOutputs')[0]

def DiagnosticPenaltyFactorEnum():
	"""
	DIAGNOSTICPENALTYFACTORENUM - Enum of DiagnosticPenaltyFactor

	   Usage:
	      macro=DiagnosticPenaltyFactorEnum()
	"""

	return StringToEnum('DiagnosticPenaltyFactor')[0]

def DiagnosticReferentialEnum():
	"""
	DIAGNOSTICREFERENTIALENUM - Enum of DiagnosticReferential

	   Usage:
	      macro=DiagnosticReferentialEnum()
	"""

	return StringToEnum('DiagnosticReferential')[0]

def DiagnosticReltolEnum():
	"""
	DIAGNOSTICRELTOLENUM - Enum of DiagnosticReltol

	   Usage:
	      macro=DiagnosticReltolEnum()
	"""

	return StringToEnum('DiagnosticReltol')[0]

def DiagnosticRequestedOutputsEnum():
	"""
	DIAGNOSTICREQUESTEDOUTPUTSENUM - Enum of DiagnosticRequestedOutputs

	   Usage:
	      macro=DiagnosticRequestedOutputsEnum()
	"""

	return StringToEnum('DiagnosticRequestedOutputs')[0]

def DiagnosticRestolEnum():
	"""
	DIAGNOSTICRESTOLENUM - Enum of DiagnosticRestol

	   Usage:
	      macro=DiagnosticRestolEnum()
	"""

	return StringToEnum('DiagnosticRestol')[0]

def DiagnosticRiftPenaltyLockEnum():
	"""
	DIAGNOSTICRIFTPENALTYLOCKENUM - Enum of DiagnosticRiftPenaltyLock

	   Usage:
	      macro=DiagnosticRiftPenaltyLockEnum()
	"""

	return StringToEnum('DiagnosticRiftPenaltyLock')[0]

def DiagnosticRiftPenaltyThresholdEnum():
	"""
	DIAGNOSTICRIFTPENALTYTHRESHOLDENUM - Enum of DiagnosticRiftPenaltyThreshold

	   Usage:
	      macro=DiagnosticRiftPenaltyThresholdEnum()
	"""

	return StringToEnum('DiagnosticRiftPenaltyThreshold')[0]

def DiagnosticShelfDampeningEnum():
	"""
	DIAGNOSTICSHELFDAMPENINGENUM - Enum of DiagnosticShelfDampening

	   Usage:
	      macro=DiagnosticShelfDampeningEnum()
	"""

	return StringToEnum('DiagnosticShelfDampening')[0]

def DiagnosticSpcvxEnum():
	"""
	DIAGNOSTICSPCVXENUM - Enum of DiagnosticSpcvx

	   Usage:
	      macro=DiagnosticSpcvxEnum()
	"""

	return StringToEnum('DiagnosticSpcvx')[0]

def DiagnosticSpcvyEnum():
	"""
	DIAGNOSTICSPCVYENUM - Enum of DiagnosticSpcvy

	   Usage:
	      macro=DiagnosticSpcvyEnum()
	"""

	return StringToEnum('DiagnosticSpcvy')[0]

def DiagnosticSpcvzEnum():
	"""
	DIAGNOSTICSPCVZENUM - Enum of DiagnosticSpcvz

	   Usage:
	      macro=DiagnosticSpcvzEnum()
	"""

	return StringToEnum('DiagnosticSpcvz')[0]

def DiagnosticStokesreconditioningEnum():
	"""
	DIAGNOSTICSTOKESRECONDITIONINGENUM - Enum of DiagnosticStokesreconditioning

	   Usage:
	      macro=DiagnosticStokesreconditioningEnum()
	"""

	return StringToEnum('DiagnosticStokesreconditioning')[0]

def DiagnosticVertexPairingEnum():
	"""
	DIAGNOSTICVERTEXPAIRINGENUM - Enum of DiagnosticVertexPairing

	   Usage:
	      macro=DiagnosticVertexPairingEnum()
	"""

	return StringToEnum('DiagnosticVertexPairing')[0]

def DiagnosticViscosityOvershootEnum():
	"""
	DIAGNOSTICVISCOSITYOVERSHOOTENUM - Enum of DiagnosticViscosityOvershoot

	   Usage:
	      macro=DiagnosticViscosityOvershootEnum()
	"""

	return StringToEnum('DiagnosticViscosityOvershoot')[0]

def FlowequationBordermacayealEnum():
	"""
	FLOWEQUATIONBORDERMACAYEALENUM - Enum of FlowequationBordermacayeal

	   Usage:
	      macro=FlowequationBordermacayealEnum()
	"""

	return StringToEnum('FlowequationBordermacayeal')[0]

def FlowequationBorderpattynEnum():
	"""
	FLOWEQUATIONBORDERPATTYNENUM - Enum of FlowequationBorderpattyn

	   Usage:
	      macro=FlowequationBorderpattynEnum()
	"""

	return StringToEnum('FlowequationBorderpattyn')[0]

def FlowequationBorderstokesEnum():
	"""
	FLOWEQUATIONBORDERSTOKESENUM - Enum of FlowequationBorderstokes

	   Usage:
	      macro=FlowequationBorderstokesEnum()
	"""

	return StringToEnum('FlowequationBorderstokes')[0]

def FlowequationElementEquationEnum():
	"""
	FLOWEQUATIONELEMENTEQUATIONENUM - Enum of FlowequationElementEquation

	   Usage:
	      macro=FlowequationElementEquationEnum()
	"""

	return StringToEnum('FlowequationElementEquation')[0]

def FlowequationIshutterEnum():
	"""
	FLOWEQUATIONISHUTTERENUM - Enum of FlowequationIshutter

	   Usage:
	      macro=FlowequationIshutterEnum()
	"""

	return StringToEnum('FlowequationIshutter')[0]

def FlowequationIsl1l2Enum():
	"""
	FLOWEQUATIONISL1L2ENUM - Enum of FlowequationIsl1l2

	   Usage:
	      macro=FlowequationIsl1l2Enum()
	"""

	return StringToEnum('FlowequationIsl1l2')[0]

def FlowequationIsmacayealpattynEnum():
	"""
	FLOWEQUATIONISMACAYEALPATTYNENUM - Enum of FlowequationIsmacayealpattyn

	   Usage:
	      macro=FlowequationIsmacayealpattynEnum()
	"""

	return StringToEnum('FlowequationIsmacayealpattyn')[0]

def FlowequationIsstokesEnum():
	"""
	FLOWEQUATIONISSTOKESENUM - Enum of FlowequationIsstokes

	   Usage:
	      macro=FlowequationIsstokesEnum()
	"""

	return StringToEnum('FlowequationIsstokes')[0]

def FlowequationVertexEquationEnum():
	"""
	FLOWEQUATIONVERTEXEQUATIONENUM - Enum of FlowequationVertexEquation

	   Usage:
	      macro=FlowequationVertexEquationEnum()
	"""

	return StringToEnum('FlowequationVertexEquation')[0]

def FrictionCoefficientEnum():
	"""
	FRICTIONCOEFFICIENTENUM - Enum of FrictionCoefficient

	   Usage:
	      macro=FrictionCoefficientEnum()
	"""

	return StringToEnum('FrictionCoefficient')[0]

def FrictionPEnum():
	"""
	FRICTIONPENUM - Enum of FrictionP

	   Usage:
	      macro=FrictionPEnum()
	"""

	return StringToEnum('FrictionP')[0]

def FrictionQEnum():
	"""
	FRICTIONQENUM - Enum of FrictionQ

	   Usage:
	      macro=FrictionQEnum()
	"""

	return StringToEnum('FrictionQ')[0]

def GeometryHydrostaticRatioEnum():
	"""
	GEOMETRYHYDROSTATICRATIOENUM - Enum of GeometryHydrostaticRatio

	   Usage:
	      macro=GeometryHydrostaticRatioEnum()
	"""

	return StringToEnum('GeometryHydrostaticRatio')[0]

def HydrologyCREnum():
	"""
	HYDROLOGYCRENUM - Enum of HydrologyCR

	   Usage:
	      macro=HydrologyCREnum()
	"""

	return StringToEnum('HydrologyCR')[0]

def HydrologyKnEnum():
	"""
	HYDROLOGYKNENUM - Enum of HydrologyKn

	   Usage:
	      macro=HydrologyKnEnum()
	"""

	return StringToEnum('HydrologyKn')[0]

def HydrologyNEnum():
	"""
	HYDROLOGYNENUM - Enum of HydrologyN

	   Usage:
	      macro=HydrologyNEnum()
	"""

	return StringToEnum('HydrologyN')[0]

def HydrologyPEnum():
	"""
	HYDROLOGYPENUM - Enum of HydrologyP

	   Usage:
	      macro=HydrologyPEnum()
	"""

	return StringToEnum('HydrologyP')[0]

def HydrologyQEnum():
	"""
	HYDROLOGYQENUM - Enum of HydrologyQ

	   Usage:
	      macro=HydrologyQEnum()
	"""

	return StringToEnum('HydrologyQ')[0]

def HydrologySpcwatercolumnEnum():
	"""
	HYDROLOGYSPCWATERCOLUMNENUM - Enum of HydrologySpcwatercolumn

	   Usage:
	      macro=HydrologySpcwatercolumnEnum()
	"""

	return StringToEnum('HydrologySpcwatercolumn')[0]

def HydrologyStabilizationEnum():
	"""
	HYDROLOGYSTABILIZATIONENUM - Enum of HydrologyStabilization

	   Usage:
	      macro=HydrologyStabilizationEnum()
	"""

	return StringToEnum('HydrologyStabilization')[0]

def IndependentObjectEnum():
	"""
	INDEPENDENTOBJECTENUM - Enum of IndependentObject

	   Usage:
	      macro=IndependentObjectEnum()
	"""

	return StringToEnum('IndependentObject')[0]

def InversionControlParametersEnum():
	"""
	INVERSIONCONTROLPARAMETERSENUM - Enum of InversionControlParameters

	   Usage:
	      macro=InversionControlParametersEnum()
	"""

	return StringToEnum('InversionControlParameters')[0]

def InversionCostFunctionEnum():
	"""
	INVERSIONCOSTFUNCTIONENUM - Enum of InversionCostFunction

	   Usage:
	      macro=InversionCostFunctionEnum()
	"""

	return StringToEnum('InversionCostFunction')[0]

def InversionCostFunctionThresholdEnum():
	"""
	INVERSIONCOSTFUNCTIONTHRESHOLDENUM - Enum of InversionCostFunctionThreshold

	   Usage:
	      macro=InversionCostFunctionThresholdEnum()
	"""

	return StringToEnum('InversionCostFunctionThreshold')[0]

def InversionCostFunctionsCoefficientsEnum():
	"""
	INVERSIONCOSTFUNCTIONSCOEFFICIENTSENUM - Enum of InversionCostFunctionsCoefficients

	   Usage:
	      macro=InversionCostFunctionsCoefficientsEnum()
	"""

	return StringToEnum('InversionCostFunctionsCoefficients')[0]

def InversionCostFunctionsEnum():
	"""
	INVERSIONCOSTFUNCTIONSENUM - Enum of InversionCostFunctions

	   Usage:
	      macro=InversionCostFunctionsEnum()
	"""

	return StringToEnum('InversionCostFunctions')[0]

def InversionGradientOnlyEnum():
	"""
	INVERSIONGRADIENTONLYENUM - Enum of InversionGradientOnly

	   Usage:
	      macro=InversionGradientOnlyEnum()
	"""

	return StringToEnum('InversionGradientOnly')[0]

def InversionGradientScalingEnum():
	"""
	INVERSIONGRADIENTSCALINGENUM - Enum of InversionGradientScaling

	   Usage:
	      macro=InversionGradientScalingEnum()
	"""

	return StringToEnum('InversionGradientScaling')[0]

def InversionIscontrolEnum():
	"""
	INVERSIONISCONTROLENUM - Enum of InversionIscontrol

	   Usage:
	      macro=InversionIscontrolEnum()
	"""

	return StringToEnum('InversionIscontrol')[0]

def InversionTaoEnum():
	"""
	INVERSIONTAOENUM - Enum of InversionTao

	   Usage:
	      macro=InversionTaoEnum()
	"""

	return StringToEnum('InversionTao')[0]

def InversionIncompleteAdjointEnum():
	"""
	INVERSIONINCOMPLETEADJOINTENUM - Enum of InversionIncompleteAdjoint

	   Usage:
	      macro=InversionIncompleteAdjointEnum()
	"""

	return StringToEnum('InversionIncompleteAdjoint')[0]

def InversionMaxParametersEnum():
	"""
	INVERSIONMAXPARAMETERSENUM - Enum of InversionMaxParameters

	   Usage:
	      macro=InversionMaxParametersEnum()
	"""

	return StringToEnum('InversionMaxParameters')[0]

def InversionMaxiterPerStepEnum():
	"""
	INVERSIONMAXITERPERSTEPENUM - Enum of InversionMaxiterPerStep

	   Usage:
	      macro=InversionMaxiterPerStepEnum()
	"""

	return StringToEnum('InversionMaxiterPerStep')[0]

def InversionMinParametersEnum():
	"""
	INVERSIONMINPARAMETERSENUM - Enum of InversionMinParameters

	   Usage:
	      macro=InversionMinParametersEnum()
	"""

	return StringToEnum('InversionMinParameters')[0]

def InversionNstepsEnum():
	"""
	INVERSIONNSTEPSENUM - Enum of InversionNsteps

	   Usage:
	      macro=InversionNstepsEnum()
	"""

	return StringToEnum('InversionNsteps')[0]

def InversionNumControlParametersEnum():
	"""
	INVERSIONNUMCONTROLPARAMETERSENUM - Enum of InversionNumControlParameters

	   Usage:
	      macro=InversionNumControlParametersEnum()
	"""

	return StringToEnum('InversionNumControlParameters')[0]

def InversionNumCostFunctionsEnum():
	"""
	INVERSIONNUMCOSTFUNCTIONSENUM - Enum of InversionNumCostFunctions

	   Usage:
	      macro=InversionNumCostFunctionsEnum()
	"""

	return StringToEnum('InversionNumCostFunctions')[0]

def InversionStepThresholdEnum():
	"""
	INVERSIONSTEPTHRESHOLDENUM - Enum of InversionStepThreshold

	   Usage:
	      macro=InversionStepThresholdEnum()
	"""

	return StringToEnum('InversionStepThreshold')[0]

def InversionThicknessObsEnum():
	"""
	INVERSIONTHICKNESSOBSENUM - Enum of InversionThicknessObs

	   Usage:
	      macro=InversionThicknessObsEnum()
	"""

	return StringToEnum('InversionThicknessObs')[0]

def InversionVelObsEnum():
	"""
	INVERSIONVELOBSENUM - Enum of InversionVelObs

	   Usage:
	      macro=InversionVelObsEnum()
	"""

	return StringToEnum('InversionVelObs')[0]

def InversionVxObsEnum():
	"""
	INVERSIONVXOBSENUM - Enum of InversionVxObs

	   Usage:
	      macro=InversionVxObsEnum()
	"""

	return StringToEnum('InversionVxObs')[0]

def InversionVyObsEnum():
	"""
	INVERSIONVYOBSENUM - Enum of InversionVyObs

	   Usage:
	      macro=InversionVyObsEnum()
	"""

	return StringToEnum('InversionVyObs')[0]

def InversionVzObsEnum():
	"""
	INVERSIONVZOBSENUM - Enum of InversionVzObs

	   Usage:
	      macro=InversionVzObsEnum()
	"""

	return StringToEnum('InversionVzObs')[0]

def MaskElementonfloatingiceEnum():
	"""
	MASKELEMENTONFLOATINGICEENUM - Enum of MaskElementonfloatingice

	   Usage:
	      macro=MaskElementonfloatingiceEnum()
	"""

	return StringToEnum('MaskElementonfloatingice')[0]

def MaskElementongroundediceEnum():
	"""
	MASKELEMENTONGROUNDEDICEENUM - Enum of MaskElementongroundedice

	   Usage:
	      macro=MaskElementongroundediceEnum()
	"""

	return StringToEnum('MaskElementongroundedice')[0]

def MaskElementonwaterEnum():
	"""
	MASKELEMENTONWATERENUM - Enum of MaskElementonwater

	   Usage:
	      macro=MaskElementonwaterEnum()
	"""

	return StringToEnum('MaskElementonwater')[0]

def MaskVertexonfloatingiceEnum():
	"""
	MASKVERTEXONFLOATINGICEENUM - Enum of MaskVertexonfloatingice

	   Usage:
	      macro=MaskVertexonfloatingiceEnum()
	"""

	return StringToEnum('MaskVertexonfloatingice')[0]

def MaskVertexongroundediceEnum():
	"""
	MASKVERTEXONGROUNDEDICEENUM - Enum of MaskVertexongroundedice

	   Usage:
	      macro=MaskVertexongroundediceEnum()
	"""

	return StringToEnum('MaskVertexongroundedice')[0]

def MaskVertexonwaterEnum():
	"""
	MASKVERTEXONWATERENUM - Enum of MaskVertexonwater

	   Usage:
	      macro=MaskVertexonwaterEnum()
	"""

	return StringToEnum('MaskVertexonwater')[0]

def MaterialsBetaEnum():
	"""
	MATERIALSBETAENUM - Enum of MaterialsBeta

	   Usage:
	      macro=MaterialsBetaEnum()
	"""

	return StringToEnum('MaterialsBeta')[0]

def MaterialsHeatcapacityEnum():
	"""
	MATERIALSHEATCAPACITYENUM - Enum of MaterialsHeatcapacity

	   Usage:
	      macro=MaterialsHeatcapacityEnum()
	"""

	return StringToEnum('MaterialsHeatcapacity')[0]

def MaterialsLatentheatEnum():
	"""
	MATERIALSLATENTHEATENUM - Enum of MaterialsLatentheat

	   Usage:
	      macro=MaterialsLatentheatEnum()
	"""

	return StringToEnum('MaterialsLatentheat')[0]

def MaterialsMeltingpointEnum():
	"""
	MATERIALSMELTINGPOINTENUM - Enum of MaterialsMeltingpoint

	   Usage:
	      macro=MaterialsMeltingpointEnum()
	"""

	return StringToEnum('MaterialsMeltingpoint')[0]

def MaterialsMixedLayerCapacityEnum():
	"""
	MATERIALSMIXEDLAYERCAPACITYENUM - Enum of MaterialsMixedLayerCapacity

	   Usage:
	      macro=MaterialsMixedLayerCapacityEnum()
	"""

	return StringToEnum('MaterialsMixedLayerCapacity')[0]

def MaterialsRheologyBEnum():
	"""
	MATERIALSRHEOLOGYBENUM - Enum of MaterialsRheologyB

	   Usage:
	      macro=MaterialsRheologyBEnum()
	"""

	return StringToEnum('MaterialsRheologyB')[0]

def MaterialsRheologyBbarEnum():
	"""
	MATERIALSRHEOLOGYBBARENUM - Enum of MaterialsRheologyBbar

	   Usage:
	      macro=MaterialsRheologyBbarEnum()
	"""

	return StringToEnum('MaterialsRheologyBbar')[0]

def MaterialsRheologyLawEnum():
	"""
	MATERIALSRHEOLOGYLAWENUM - Enum of MaterialsRheologyLaw

	   Usage:
	      macro=MaterialsRheologyLawEnum()
	"""

	return StringToEnum('MaterialsRheologyLaw')[0]

def MaterialsRheologyNEnum():
	"""
	MATERIALSRHEOLOGYNENUM - Enum of MaterialsRheologyN

	   Usage:
	      macro=MaterialsRheologyNEnum()
	"""

	return StringToEnum('MaterialsRheologyN')[0]

def MaterialsRheologyZEnum():
	"""
	MATERIALSRHEOLOGYZENUM - Enum of MaterialsRheologyZ

	   Usage:
	      macro=MaterialsRheologyZEnum()
	"""

	return StringToEnum('MaterialsRheologyZ')[0]

def MaterialsRheologyZbarEnum():
	"""
	MATERIALSRHEOLOGYZBARENUM - Enum of MaterialsRheologyZbar

	   Usage:
	      macro=MaterialsRheologyZbarEnum()
	"""

	return StringToEnum('MaterialsRheologyZbar')[0]

def MaterialsRhoIceEnum():
	"""
	MATERIALSRHOICEENUM - Enum of MaterialsRhoIce

	   Usage:
	      macro=MaterialsRhoIceEnum()
	"""

	return StringToEnum('MaterialsRhoIce')[0]

def MaterialsRhoWaterEnum():
	"""
	MATERIALSRHOWATERENUM - Enum of MaterialsRhoWater

	   Usage:
	      macro=MaterialsRhoWaterEnum()
	"""

	return StringToEnum('MaterialsRhoWater')[0]

def MaterialsRhoFreshwaterEnum():
	"""
	MATERIALSRHOFRESHWATERENUM - Enum of MaterialsRhoFreshwater

	   Usage:
	      macro=MaterialsRhoFreshwaterEnum()
	"""

	return StringToEnum('MaterialsRhoFreshwater')[0]

def MaterialsMuWaterEnum():
	"""
	MATERIALSMUWATERENUM - Enum of MaterialsMuWater

	   Usage:
	      macro=MaterialsMuWaterEnum()
	"""

	return StringToEnum('MaterialsMuWater')[0]

def MaterialsThermalExchangeVelocityEnum():
	"""
	MATERIALSTHERMALEXCHANGEVELOCITYENUM - Enum of MaterialsThermalExchangeVelocity

	   Usage:
	      macro=MaterialsThermalExchangeVelocityEnum()
	"""

	return StringToEnum('MaterialsThermalExchangeVelocity')[0]

def MaterialsThermalconductivityEnum():
	"""
	MATERIALSTHERMALCONDUCTIVITYENUM - Enum of MaterialsThermalconductivity

	   Usage:
	      macro=MaterialsThermalconductivityEnum()
	"""

	return StringToEnum('MaterialsThermalconductivity')[0]

def MeshAverageVertexConnectivityEnum():
	"""
	MESHAVERAGEVERTEXCONNECTIVITYENUM - Enum of MeshAverageVertexConnectivity

	   Usage:
	      macro=MeshAverageVertexConnectivityEnum()
	"""

	return StringToEnum('MeshAverageVertexConnectivity')[0]

def MeshDimensionEnum():
	"""
	MESHDIMENSIONENUM - Enum of MeshDimension

	   Usage:
	      macro=MeshDimensionEnum()
	"""

	return StringToEnum('MeshDimension')[0]

def MeshEdgesEnum():
	"""
	MESHEDGESENUM - Enum of MeshEdges

	   Usage:
	      macro=MeshEdgesEnum()
	"""

	return StringToEnum('MeshEdges')[0]

def MeshElementconnectivityEnum():
	"""
	MESHELEMENTCONNECTIVITYENUM - Enum of MeshElementconnectivity

	   Usage:
	      macro=MeshElementconnectivityEnum()
	"""

	return StringToEnum('MeshElementconnectivity')[0]

def MeshElementonbedEnum():
	"""
	MESHELEMENTONBEDENUM - Enum of MeshElementonbed

	   Usage:
	      macro=MeshElementonbedEnum()
	"""

	return StringToEnum('MeshElementonbed')[0]

def MeshElementonsurfaceEnum():
	"""
	MESHELEMENTONSURFACEENUM - Enum of MeshElementonsurface

	   Usage:
	      macro=MeshElementonsurfaceEnum()
	"""

	return StringToEnum('MeshElementonsurface')[0]

def MeshElements2dEnum():
	"""
	MESHELEMENTS2DENUM - Enum of MeshElements2d

	   Usage:
	      macro=MeshElements2dEnum()
	"""

	return StringToEnum('MeshElements2d')[0]

def MeshElementsEnum():
	"""
	MESHELEMENTSENUM - Enum of MeshElements

	   Usage:
	      macro=MeshElementsEnum()
	"""

	return StringToEnum('MeshElements')[0]

def MeshLowerelementsEnum():
	"""
	MESHLOWERELEMENTSENUM - Enum of MeshLowerelements

	   Usage:
	      macro=MeshLowerelementsEnum()
	"""

	return StringToEnum('MeshLowerelements')[0]

def MeshNumberofedgesEnum():
	"""
	MESHNUMBEROFEDGESENUM - Enum of MeshNumberofedges

	   Usage:
	      macro=MeshNumberofedgesEnum()
	"""

	return StringToEnum('MeshNumberofedges')[0]

def MeshNumberofelements2dEnum():
	"""
	MESHNUMBEROFELEMENTS2DENUM - Enum of MeshNumberofelements2d

	   Usage:
	      macro=MeshNumberofelements2dEnum()
	"""

	return StringToEnum('MeshNumberofelements2d')[0]

def MeshNumberofelementsEnum():
	"""
	MESHNUMBEROFELEMENTSENUM - Enum of MeshNumberofelements

	   Usage:
	      macro=MeshNumberofelementsEnum()
	"""

	return StringToEnum('MeshNumberofelements')[0]

def MeshNumberoflayersEnum():
	"""
	MESHNUMBEROFLAYERSENUM - Enum of MeshNumberoflayers

	   Usage:
	      macro=MeshNumberoflayersEnum()
	"""

	return StringToEnum('MeshNumberoflayers')[0]

def MeshNumberofvertices2dEnum():
	"""
	MESHNUMBEROFVERTICES2DENUM - Enum of MeshNumberofvertices2d

	   Usage:
	      macro=MeshNumberofvertices2dEnum()
	"""

	return StringToEnum('MeshNumberofvertices2d')[0]

def MeshNumberofverticesEnum():
	"""
	MESHNUMBEROFVERTICESENUM - Enum of MeshNumberofvertices

	   Usage:
	      macro=MeshNumberofverticesEnum()
	"""

	return StringToEnum('MeshNumberofvertices')[0]

def MeshUpperelementsEnum():
	"""
	MESHUPPERELEMENTSENUM - Enum of MeshUpperelements

	   Usage:
	      macro=MeshUpperelementsEnum()
	"""

	return StringToEnum('MeshUpperelements')[0]

def MeshVertexonbedEnum():
	"""
	MESHVERTEXONBEDENUM - Enum of MeshVertexonbed

	   Usage:
	      macro=MeshVertexonbedEnum()
	"""

	return StringToEnum('MeshVertexonbed')[0]

def MeshVertexonsurfaceEnum():
	"""
	MESHVERTEXONSURFACEENUM - Enum of MeshVertexonsurface

	   Usage:
	      macro=MeshVertexonsurfaceEnum()
	"""

	return StringToEnum('MeshVertexonsurface')[0]

def MeshXEnum():
	"""
	MESHXENUM - Enum of MeshX

	   Usage:
	      macro=MeshXEnum()
	"""

	return StringToEnum('MeshX')[0]

def MeshYEnum():
	"""
	MESHYENUM - Enum of MeshY

	   Usage:
	      macro=MeshYEnum()
	"""

	return StringToEnum('MeshY')[0]

def MeshZEnum():
	"""
	MESHZENUM - Enum of MeshZ

	   Usage:
	      macro=MeshZEnum()
	"""

	return StringToEnum('MeshZ')[0]

def MiscellaneousNameEnum():
	"""
	MISCELLANEOUSNAMEENUM - Enum of MiscellaneousName

	   Usage:
	      macro=MiscellaneousNameEnum()
	"""

	return StringToEnum('MiscellaneousName')[0]

def PrognosticHydrostaticAdjustmentEnum():
	"""
	PROGNOSTICHYDROSTATICADJUSTMENTENUM - Enum of PrognosticHydrostaticAdjustment

	   Usage:
	      macro=PrognosticHydrostaticAdjustmentEnum()
	"""

	return StringToEnum('PrognosticHydrostaticAdjustment')[0]

def PrognosticMinThicknessEnum():
	"""
	PROGNOSTICMINTHICKNESSENUM - Enum of PrognosticMinThickness

	   Usage:
	      macro=PrognosticMinThicknessEnum()
	"""

	return StringToEnum('PrognosticMinThickness')[0]

def PrognosticPenaltyFactorEnum():
	"""
	PROGNOSTICPENALTYFACTORENUM - Enum of PrognosticPenaltyFactor

	   Usage:
	      macro=PrognosticPenaltyFactorEnum()
	"""

	return StringToEnum('PrognosticPenaltyFactor')[0]

def PrognosticSpcthicknessEnum():
	"""
	PROGNOSTICSPCTHICKNESSENUM - Enum of PrognosticSpcthickness

	   Usage:
	      macro=PrognosticSpcthicknessEnum()
	"""

	return StringToEnum('PrognosticSpcthickness')[0]

def PrognosticStabilizationEnum():
	"""
	PROGNOSTICSTABILIZATIONENUM - Enum of PrognosticStabilization

	   Usage:
	      macro=PrognosticStabilizationEnum()
	"""

	return StringToEnum('PrognosticStabilization')[0]

def PrognosticVertexPairingEnum():
	"""
	PROGNOSTICVERTEXPAIRINGENUM - Enum of PrognosticVertexPairing

	   Usage:
	      macro=PrognosticVertexPairingEnum()
	"""

	return StringToEnum('PrognosticVertexPairing')[0]

def PrognosticNumRequestedOutputsEnum():
	"""
	PROGNOSTICNUMREQUESTEDOUTPUTSENUM - Enum of PrognosticNumRequestedOutputs

	   Usage:
	      macro=PrognosticNumRequestedOutputsEnum()
	"""

	return StringToEnum('PrognosticNumRequestedOutputs')[0]

def PrognosticRequestedOutputsEnum():
	"""
	PROGNOSTICREQUESTEDOUTPUTSENUM - Enum of PrognosticRequestedOutputs

	   Usage:
	      macro=PrognosticRequestedOutputsEnum()
	"""

	return StringToEnum('PrognosticRequestedOutputs')[0]

def QmuIsdakotaEnum():
	"""
	QMUISDAKOTAENUM - Enum of QmuIsdakota

	   Usage:
	      macro=QmuIsdakotaEnum()
	"""

	return StringToEnum('QmuIsdakota')[0]

def MassFluxSegmentsEnum():
	"""
	MASSFLUXSEGMENTSENUM - Enum of MassFluxSegments

	   Usage:
	      macro=MassFluxSegmentsEnum()
	"""

	return StringToEnum('MassFluxSegments')[0]

def MassFluxSegmentsPresentEnum():
	"""
	MASSFLUXSEGMENTSPRESENTENUM - Enum of MassFluxSegmentsPresent

	   Usage:
	      macro=MassFluxSegmentsPresentEnum()
	"""

	return StringToEnum('MassFluxSegmentsPresent')[0]

def QmuMassFluxSegmentsPresentEnum():
	"""
	QMUMASSFLUXSEGMENTSPRESENTENUM - Enum of QmuMassFluxSegmentsPresent

	   Usage:
	      macro=QmuMassFluxSegmentsPresentEnum()
	"""

	return StringToEnum('QmuMassFluxSegmentsPresent')[0]

def QmuNumberofpartitionsEnum():
	"""
	QMUNUMBEROFPARTITIONSENUM - Enum of QmuNumberofpartitions

	   Usage:
	      macro=QmuNumberofpartitionsEnum()
	"""

	return StringToEnum('QmuNumberofpartitions')[0]

def QmuNumberofresponsesEnum():
	"""
	QMUNUMBEROFRESPONSESENUM - Enum of QmuNumberofresponses

	   Usage:
	      macro=QmuNumberofresponsesEnum()
	"""

	return StringToEnum('QmuNumberofresponses')[0]

def QmuPartitionEnum():
	"""
	QMUPARTITIONENUM - Enum of QmuPartition

	   Usage:
	      macro=QmuPartitionEnum()
	"""

	return StringToEnum('QmuPartition')[0]

def QmuResponsedescriptorsEnum():
	"""
	QMURESPONSEDESCRIPTORSENUM - Enum of QmuResponsedescriptors

	   Usage:
	      macro=QmuResponsedescriptorsEnum()
	"""

	return StringToEnum('QmuResponsedescriptors')[0]

def QmuVariabledescriptorsEnum():
	"""
	QMUVARIABLEDESCRIPTORSENUM - Enum of QmuVariabledescriptors

	   Usage:
	      macro=QmuVariabledescriptorsEnum()
	"""

	return StringToEnum('QmuVariabledescriptors')[0]

def RiftsNumriftsEnum():
	"""
	RIFTSNUMRIFTSENUM - Enum of RiftsNumrifts

	   Usage:
	      macro=RiftsNumriftsEnum()
	"""

	return StringToEnum('RiftsNumrifts')[0]

def RiftsRiftstructEnum():
	"""
	RIFTSRIFTSTRUCTENUM - Enum of RiftsRiftstruct

	   Usage:
	      macro=RiftsRiftstructEnum()
	"""

	return StringToEnum('RiftsRiftstruct')[0]

def SettingsIoGatherEnum():
	"""
	SETTINGSIOGATHERENUM - Enum of SettingsIoGather

	   Usage:
	      macro=SettingsIoGatherEnum()
	"""

	return StringToEnum('SettingsIoGather')[0]

def SettingsLowmemEnum():
	"""
	SETTINGSLOWMEMENUM - Enum of SettingsLowmem

	   Usage:
	      macro=SettingsLowmemEnum()
	"""

	return StringToEnum('SettingsLowmem')[0]

def SettingsOutputFrequencyEnum():
	"""
	SETTINGSOUTPUTFREQUENCYENUM - Enum of SettingsOutputFrequency

	   Usage:
	      macro=SettingsOutputFrequencyEnum()
	"""

	return StringToEnum('SettingsOutputFrequency')[0]

def SettingsResultsAsPatchesEnum():
	"""
	SETTINGSRESULTSASPATCHESENUM - Enum of SettingsResultsAsPatches

	   Usage:
	      macro=SettingsResultsAsPatchesEnum()
	"""

	return StringToEnum('SettingsResultsAsPatches')[0]

def SettingsWaitonlockEnum():
	"""
	SETTINGSWAITONLOCKENUM - Enum of SettingsWaitonlock

	   Usage:
	      macro=SettingsWaitonlockEnum()
	"""

	return StringToEnum('SettingsWaitonlock')[0]

def SurfaceforcingsDelta18oEnum():
	"""
	SURFACEFORCINGSDELTA18OENUM - Enum of SurfaceforcingsDelta18o

	   Usage:
	      macro=SurfaceforcingsDelta18oEnum()
	"""

	return StringToEnum('SurfaceforcingsDelta18o')[0]

def SurfaceforcingsDelta18oSurfaceEnum():
	"""
	SURFACEFORCINGSDELTA18OSURFACEENUM - Enum of SurfaceforcingsDelta18oSurface

	   Usage:
	      macro=SurfaceforcingsDelta18oSurfaceEnum()
	"""

	return StringToEnum('SurfaceforcingsDelta18oSurface')[0]

def SurfaceforcingsIsdelta18oEnum():
	"""
	SURFACEFORCINGSISDELTA18OENUM - Enum of SurfaceforcingsIsdelta18o

	   Usage:
	      macro=SurfaceforcingsIsdelta18oEnum()
	"""

	return StringToEnum('SurfaceforcingsIsdelta18o')[0]

def SurfaceforcingsPrecipitationsPresentdayEnum():
	"""
	SURFACEFORCINGSPRECIPITATIONSPRESENTDAYENUM - Enum of SurfaceforcingsPrecipitationsPresentday

	   Usage:
	      macro=SurfaceforcingsPrecipitationsPresentdayEnum()
	"""

	return StringToEnum('SurfaceforcingsPrecipitationsPresentday')[0]

def SurfaceforcingsTemperaturesPresentdayEnum():
	"""
	SURFACEFORCINGSTEMPERATURESPRESENTDAYENUM - Enum of SurfaceforcingsTemperaturesPresentday

	   Usage:
	      macro=SurfaceforcingsTemperaturesPresentdayEnum()
	"""

	return StringToEnum('SurfaceforcingsTemperaturesPresentday')[0]

def SurfaceforcingsTemperaturesLgmEnum():
	"""
	SURFACEFORCINGSTEMPERATURESLGMENUM - Enum of SurfaceforcingsTemperaturesLgm

	   Usage:
	      macro=SurfaceforcingsTemperaturesLgmEnum()
	"""

	return StringToEnum('SurfaceforcingsTemperaturesLgm')[0]

def DebugProfilingEnum():
	"""
	DEBUGPROFILINGENUM - Enum of DebugProfiling

	   Usage:
	      macro=DebugProfilingEnum()
	"""

	return StringToEnum('DebugProfiling')[0]

def ProfilingCurrentMemEnum():
	"""
	PROFILINGCURRENTMEMENUM - Enum of ProfilingCurrentMem

	   Usage:
	      macro=ProfilingCurrentMemEnum()
	"""

	return StringToEnum('ProfilingCurrentMem')[0]

def ProfilingCurrentFlopsEnum():
	"""
	PROFILINGCURRENTFLOPSENUM - Enum of ProfilingCurrentFlops

	   Usage:
	      macro=ProfilingCurrentFlopsEnum()
	"""

	return StringToEnum('ProfilingCurrentFlops')[0]

def ProfilingSolutionTimeEnum():
	"""
	PROFILINGSOLUTIONTIMEENUM - Enum of ProfilingSolutionTime

	   Usage:
	      macro=ProfilingSolutionTimeEnum()
	"""

	return StringToEnum('ProfilingSolutionTime')[0]

def MaxIterationConvergenceFlagEnum():
	"""
	MAXITERATIONCONVERGENCEFLAGENUM - Enum of MaxIterationConvergenceFlag

	   Usage:
	      macro=MaxIterationConvergenceFlagEnum()
	"""

	return StringToEnum('MaxIterationConvergenceFlag')[0]

def SteadystateMaxiterEnum():
	"""
	STEADYSTATEMAXITERENUM - Enum of SteadystateMaxiter

	   Usage:
	      macro=SteadystateMaxiterEnum()
	"""

	return StringToEnum('SteadystateMaxiter')[0]

def SteadystateNumRequestedOutputsEnum():
	"""
	STEADYSTATENUMREQUESTEDOUTPUTSENUM - Enum of SteadystateNumRequestedOutputs

	   Usage:
	      macro=SteadystateNumRequestedOutputsEnum()
	"""

	return StringToEnum('SteadystateNumRequestedOutputs')[0]

def SteadystateReltolEnum():
	"""
	STEADYSTATERELTOLENUM - Enum of SteadystateReltol

	   Usage:
	      macro=SteadystateReltolEnum()
	"""

	return StringToEnum('SteadystateReltol')[0]

def SteadystateRequestedOutputsEnum():
	"""
	STEADYSTATEREQUESTEDOUTPUTSENUM - Enum of SteadystateRequestedOutputs

	   Usage:
	      macro=SteadystateRequestedOutputsEnum()
	"""

	return StringToEnum('SteadystateRequestedOutputs')[0]

def SurfaceEnum():
	"""
	SURFACEENUM - Enum of Surface

	   Usage:
	      macro=SurfaceEnum()
	"""

	return StringToEnum('Surface')[0]

def SurfaceforcingsPrecipitationEnum():
	"""
	SURFACEFORCINGSPRECIPITATIONENUM - Enum of SurfaceforcingsPrecipitation

	   Usage:
	      macro=SurfaceforcingsPrecipitationEnum()
	"""

	return StringToEnum('SurfaceforcingsPrecipitation')[0]

def SurfaceforcingsMassBalanceEnum():
	"""
	SURFACEFORCINGSMASSBALANCEENUM - Enum of SurfaceforcingsMassBalance

	   Usage:
	      macro=SurfaceforcingsMassBalanceEnum()
	"""

	return StringToEnum('SurfaceforcingsMassBalance')[0]

def SurfaceforcingsIspddEnum():
	"""
	SURFACEFORCINGSISPDDENUM - Enum of SurfaceforcingsIspdd

	   Usage:
	      macro=SurfaceforcingsIspddEnum()
	"""

	return StringToEnum('SurfaceforcingsIspdd')[0]

def SurfaceforcingsIssmbgradientsEnum():
	"""
	SURFACEFORCINGSISSMBGRADIENTSENUM - Enum of SurfaceforcingsIssmbgradients

	   Usage:
	      macro=SurfaceforcingsIssmbgradientsEnum()
	"""

	return StringToEnum('SurfaceforcingsIssmbgradients')[0]

def SurfaceforcingsMonthlytemperaturesEnum():
	"""
	SURFACEFORCINGSMONTHLYTEMPERATURESENUM - Enum of SurfaceforcingsMonthlytemperatures

	   Usage:
	      macro=SurfaceforcingsMonthlytemperaturesEnum()
	"""

	return StringToEnum('SurfaceforcingsMonthlytemperatures')[0]

def SurfaceforcingsHcEnum():
	"""
	SURFACEFORCINGSHCENUM - Enum of SurfaceforcingsHc

	   Usage:
	      macro=SurfaceforcingsHcEnum()
	"""

	return StringToEnum('SurfaceforcingsHc')[0]

def SurfaceforcingsHrefEnum():
	"""
	SURFACEFORCINGSHREFENUM - Enum of SurfaceforcingsHref

	   Usage:
	      macro=SurfaceforcingsHrefEnum()
	"""

	return StringToEnum('SurfaceforcingsHref')[0]

def SurfaceforcingsSmbrefEnum():
	"""
	SURFACEFORCINGSSMBREFENUM - Enum of SurfaceforcingsSmbref

	   Usage:
	      macro=SurfaceforcingsSmbrefEnum()
	"""

	return StringToEnum('SurfaceforcingsSmbref')[0]

def SurfaceforcingsSmbPosMaxEnum():
	"""
	SURFACEFORCINGSSMBPOSMAXENUM - Enum of SurfaceforcingsSmbPosMax

	   Usage:
	      macro=SurfaceforcingsSmbPosMaxEnum()
	"""

	return StringToEnum('SurfaceforcingsSmbPosMax')[0]

def SurfaceforcingsSmbPosMinEnum():
	"""
	SURFACEFORCINGSSMBPOSMINENUM - Enum of SurfaceforcingsSmbPosMin

	   Usage:
	      macro=SurfaceforcingsSmbPosMinEnum()
	"""

	return StringToEnum('SurfaceforcingsSmbPosMin')[0]

def SurfaceforcingsAPosEnum():
	"""
	SURFACEFORCINGSAPOSENUM - Enum of SurfaceforcingsAPos

	   Usage:
	      macro=SurfaceforcingsAPosEnum()
	"""

	return StringToEnum('SurfaceforcingsAPos')[0]

def SurfaceforcingsBPosEnum():
	"""
	SURFACEFORCINGSBPOSENUM - Enum of SurfaceforcingsBPos

	   Usage:
	      macro=SurfaceforcingsBPosEnum()
	"""

	return StringToEnum('SurfaceforcingsBPos')[0]

def SurfaceforcingsANegEnum():
	"""
	SURFACEFORCINGSANEGENUM - Enum of SurfaceforcingsANeg

	   Usage:
	      macro=SurfaceforcingsANegEnum()
	"""

	return StringToEnum('SurfaceforcingsANeg')[0]

def SurfaceforcingsBNegEnum():
	"""
	SURFACEFORCINGSBNEGENUM - Enum of SurfaceforcingsBNeg

	   Usage:
	      macro=SurfaceforcingsBNegEnum()
	"""

	return StringToEnum('SurfaceforcingsBNeg')[0]

def ThermalMaxiterEnum():
	"""
	THERMALMAXITERENUM - Enum of ThermalMaxiter

	   Usage:
	      macro=ThermalMaxiterEnum()
	"""

	return StringToEnum('ThermalMaxiter')[0]

def ThermalPenaltyFactorEnum():
	"""
	THERMALPENALTYFACTORENUM - Enum of ThermalPenaltyFactor

	   Usage:
	      macro=ThermalPenaltyFactorEnum()
	"""

	return StringToEnum('ThermalPenaltyFactor')[0]

def ThermalPenaltyLockEnum():
	"""
	THERMALPENALTYLOCKENUM - Enum of ThermalPenaltyLock

	   Usage:
	      macro=ThermalPenaltyLockEnum()
	"""

	return StringToEnum('ThermalPenaltyLock')[0]

def ThermalPenaltyThresholdEnum():
	"""
	THERMALPENALTYTHRESHOLDENUM - Enum of ThermalPenaltyThreshold

	   Usage:
	      macro=ThermalPenaltyThresholdEnum()
	"""

	return StringToEnum('ThermalPenaltyThreshold')[0]

def ThermalSpctemperatureEnum():
	"""
	THERMALSPCTEMPERATUREENUM - Enum of ThermalSpctemperature

	   Usage:
	      macro=ThermalSpctemperatureEnum()
	"""

	return StringToEnum('ThermalSpctemperature')[0]

def ThermalStabilizationEnum():
	"""
	THERMALSTABILIZATIONENUM - Enum of ThermalStabilization

	   Usage:
	      macro=ThermalStabilizationEnum()
	"""

	return StringToEnum('ThermalStabilization')[0]

def ThermalIsenthalpyEnum():
	"""
	THERMALISENTHALPYENUM - Enum of ThermalIsenthalpy

	   Usage:
	      macro=ThermalIsenthalpyEnum()
	"""

	return StringToEnum('ThermalIsenthalpy')[0]

def ThicknessEnum():
	"""
	THICKNESSENUM - Enum of Thickness

	   Usage:
	      macro=ThicknessEnum()
	"""

	return StringToEnum('Thickness')[0]

def TimesteppingStartTimeEnum():
	"""
	TIMESTEPPINGSTARTTIMEENUM - Enum of TimesteppingStartTime

	   Usage:
	      macro=TimesteppingStartTimeEnum()
	"""

	return StringToEnum('TimesteppingStartTime')[0]

def TimesteppingFinalTimeEnum():
	"""
	TIMESTEPPINGFINALTIMEENUM - Enum of TimesteppingFinalTime

	   Usage:
	      macro=TimesteppingFinalTimeEnum()
	"""

	return StringToEnum('TimesteppingFinalTime')[0]

def TimesteppingCflCoefficientEnum():
	"""
	TIMESTEPPINGCFLCOEFFICIENTENUM - Enum of TimesteppingCflCoefficient

	   Usage:
	      macro=TimesteppingCflCoefficientEnum()
	"""

	return StringToEnum('TimesteppingCflCoefficient')[0]

def TimesteppingTimeAdaptEnum():
	"""
	TIMESTEPPINGTIMEADAPTENUM - Enum of TimesteppingTimeAdapt

	   Usage:
	      macro=TimesteppingTimeAdaptEnum()
	"""

	return StringToEnum('TimesteppingTimeAdapt')[0]

def TimesteppingTimeStepEnum():
	"""
	TIMESTEPPINGTIMESTEPENUM - Enum of TimesteppingTimeStep

	   Usage:
	      macro=TimesteppingTimeStepEnum()
	"""

	return StringToEnum('TimesteppingTimeStep')[0]

def TransientIsdiagnosticEnum():
	"""
	TRANSIENTISDIAGNOSTICENUM - Enum of TransientIsdiagnostic

	   Usage:
	      macro=TransientIsdiagnosticEnum()
	"""

	return StringToEnum('TransientIsdiagnostic')[0]

def TransientIsgroundinglineEnum():
	"""
	TRANSIENTISGROUNDINGLINEENUM - Enum of TransientIsgroundingline

	   Usage:
	      macro=TransientIsgroundinglineEnum()
	"""

	return StringToEnum('TransientIsgroundingline')[0]

def TransientIsprognosticEnum():
	"""
	TRANSIENTISPROGNOSTICENUM - Enum of TransientIsprognostic

	   Usage:
	      macro=TransientIsprognosticEnum()
	"""

	return StringToEnum('TransientIsprognostic')[0]

def TransientIsthermalEnum():
	"""
	TRANSIENTISTHERMALENUM - Enum of TransientIsthermal

	   Usage:
	      macro=TransientIsthermalEnum()
	"""

	return StringToEnum('TransientIsthermal')[0]

def TransientNumRequestedOutputsEnum():
	"""
	TRANSIENTNUMREQUESTEDOUTPUTSENUM - Enum of TransientNumRequestedOutputs

	   Usage:
	      macro=TransientNumRequestedOutputsEnum()
	"""

	return StringToEnum('TransientNumRequestedOutputs')[0]

def TransientRequestedOutputsEnum():
	"""
	TRANSIENTREQUESTEDOUTPUTSENUM - Enum of TransientRequestedOutputs

	   Usage:
	      macro=TransientRequestedOutputsEnum()
	"""

	return StringToEnum('TransientRequestedOutputs')[0]

def SolutionTypeEnum():
	"""
	SOLUTIONTYPEENUM - Enum of SolutionType

	   Usage:
	      macro=SolutionTypeEnum()
	"""

	return StringToEnum('SolutionType')[0]

def AnalysisTypeEnum():
	"""
	ANALYSISTYPEENUM - Enum of AnalysisType

	   Usage:
	      macro=AnalysisTypeEnum()
	"""

	return StringToEnum('AnalysisType')[0]

def ConfigurationTypeEnum():
	"""
	CONFIGURATIONTYPEENUM - Enum of ConfigurationType

	   Usage:
	      macro=ConfigurationTypeEnum()
	"""

	return StringToEnum('ConfigurationType')[0]

def AdjointBalancethicknessAnalysisEnum():
	"""
	ADJOINTBALANCETHICKNESSANALYSISENUM - Enum of AdjointBalancethicknessAnalysis

	   Usage:
	      macro=AdjointBalancethicknessAnalysisEnum()
	"""

	return StringToEnum('AdjointBalancethicknessAnalysis')[0]

def AdjointHorizAnalysisEnum():
	"""
	ADJOINTHORIZANALYSISENUM - Enum of AdjointHorizAnalysis

	   Usage:
	      macro=AdjointHorizAnalysisEnum()
	"""

	return StringToEnum('AdjointHorizAnalysis')[0]

def AdjointSolutionEnum():
	"""
	ADJOINTSOLUTIONENUM - Enum of AdjointSolution

	   Usage:
	      macro=AdjointSolutionEnum()
	"""

	return StringToEnum('AdjointSolution')[0]

def AnalysisCounterEnum():
	"""
	ANALYSISCOUNTERENUM - Enum of AnalysisCounter

	   Usage:
	      macro=AnalysisCounterEnum()
	"""

	return StringToEnum('AnalysisCounter')[0]

def BalancethicknessAnalysisEnum():
	"""
	BALANCETHICKNESSANALYSISENUM - Enum of BalancethicknessAnalysis

	   Usage:
	      macro=BalancethicknessAnalysisEnum()
	"""

	return StringToEnum('BalancethicknessAnalysis')[0]

def BalancethicknessSolutionEnum():
	"""
	BALANCETHICKNESSSOLUTIONENUM - Enum of BalancethicknessSolution

	   Usage:
	      macro=BalancethicknessSolutionEnum()
	"""

	return StringToEnum('BalancethicknessSolution')[0]

def BedSlopeAnalysisEnum():
	"""
	BEDSLOPEANALYSISENUM - Enum of BedSlopeAnalysis

	   Usage:
	      macro=BedSlopeAnalysisEnum()
	"""

	return StringToEnum('BedSlopeAnalysis')[0]

def BedSlopeSolutionEnum():
	"""
	BEDSLOPESOLUTIONENUM - Enum of BedSlopeSolution

	   Usage:
	      macro=BedSlopeSolutionEnum()
	"""

	return StringToEnum('BedSlopeSolution')[0]

def BedSlopeXAnalysisEnum():
	"""
	BEDSLOPEXANALYSISENUM - Enum of BedSlopeXAnalysis

	   Usage:
	      macro=BedSlopeXAnalysisEnum()
	"""

	return StringToEnum('BedSlopeXAnalysis')[0]

def BedSlopeYAnalysisEnum():
	"""
	BEDSLOPEYANALYSISENUM - Enum of BedSlopeYAnalysis

	   Usage:
	      macro=BedSlopeYAnalysisEnum()
	"""

	return StringToEnum('BedSlopeYAnalysis')[0]

def DiagnosticHorizAnalysisEnum():
	"""
	DIAGNOSTICHORIZANALYSISENUM - Enum of DiagnosticHorizAnalysis

	   Usage:
	      macro=DiagnosticHorizAnalysisEnum()
	"""

	return StringToEnum('DiagnosticHorizAnalysis')[0]

def DiagnosticHutterAnalysisEnum():
	"""
	DIAGNOSTICHUTTERANALYSISENUM - Enum of DiagnosticHutterAnalysis

	   Usage:
	      macro=DiagnosticHutterAnalysisEnum()
	"""

	return StringToEnum('DiagnosticHutterAnalysis')[0]

def DiagnosticSolutionEnum():
	"""
	DIAGNOSTICSOLUTIONENUM - Enum of DiagnosticSolution

	   Usage:
	      macro=DiagnosticSolutionEnum()
	"""

	return StringToEnum('DiagnosticSolution')[0]

def DiagnosticVertAnalysisEnum():
	"""
	DIAGNOSTICVERTANALYSISENUM - Enum of DiagnosticVertAnalysis

	   Usage:
	      macro=DiagnosticVertAnalysisEnum()
	"""

	return StringToEnum('DiagnosticVertAnalysis')[0]

def EnthalpyAnalysisEnum():
	"""
	ENTHALPYANALYSISENUM - Enum of EnthalpyAnalysis

	   Usage:
	      macro=EnthalpyAnalysisEnum()
	"""

	return StringToEnum('EnthalpyAnalysis')[0]

def EnthalpySolutionEnum():
	"""
	ENTHALPYSOLUTIONENUM - Enum of EnthalpySolution

	   Usage:
	      macro=EnthalpySolutionEnum()
	"""

	return StringToEnum('EnthalpySolution')[0]

def FlaimAnalysisEnum():
	"""
	FLAIMANALYSISENUM - Enum of FlaimAnalysis

	   Usage:
	      macro=FlaimAnalysisEnum()
	"""

	return StringToEnum('FlaimAnalysis')[0]

def FlaimSolutionEnum():
	"""
	FLAIMSOLUTIONENUM - Enum of FlaimSolution

	   Usage:
	      macro=FlaimSolutionEnum()
	"""

	return StringToEnum('FlaimSolution')[0]

def HydrologyAnalysisEnum():
	"""
	HYDROLOGYANALYSISENUM - Enum of HydrologyAnalysis

	   Usage:
	      macro=HydrologyAnalysisEnum()
	"""

	return StringToEnum('HydrologyAnalysis')[0]

def HydrologySolutionEnum():
	"""
	HYDROLOGYSOLUTIONENUM - Enum of HydrologySolution

	   Usage:
	      macro=HydrologySolutionEnum()
	"""

	return StringToEnum('HydrologySolution')[0]

def MeltingAnalysisEnum():
	"""
	MELTINGANALYSISENUM - Enum of MeltingAnalysis

	   Usage:
	      macro=MeltingAnalysisEnum()
	"""

	return StringToEnum('MeltingAnalysis')[0]

def NoneAnalysisEnum():
	"""
	NONEANALYSISENUM - Enum of NoneAnalysis

	   Usage:
	      macro=NoneAnalysisEnum()
	"""

	return StringToEnum('NoneAnalysis')[0]

def PrognosticAnalysisEnum():
	"""
	PROGNOSTICANALYSISENUM - Enum of PrognosticAnalysis

	   Usage:
	      macro=PrognosticAnalysisEnum()
	"""

	return StringToEnum('PrognosticAnalysis')[0]

def PrognosticSolutionEnum():
	"""
	PROGNOSTICSOLUTIONENUM - Enum of PrognosticSolution

	   Usage:
	      macro=PrognosticSolutionEnum()
	"""

	return StringToEnum('PrognosticSolution')[0]

def SteadystateSolutionEnum():
	"""
	STEADYSTATESOLUTIONENUM - Enum of SteadystateSolution

	   Usage:
	      macro=SteadystateSolutionEnum()
	"""

	return StringToEnum('SteadystateSolution')[0]

def SurfaceSlopeAnalysisEnum():
	"""
	SURFACESLOPEANALYSISENUM - Enum of SurfaceSlopeAnalysis

	   Usage:
	      macro=SurfaceSlopeAnalysisEnum()
	"""

	return StringToEnum('SurfaceSlopeAnalysis')[0]

def SurfaceSlopeSolutionEnum():
	"""
	SURFACESLOPESOLUTIONENUM - Enum of SurfaceSlopeSolution

	   Usage:
	      macro=SurfaceSlopeSolutionEnum()
	"""

	return StringToEnum('SurfaceSlopeSolution')[0]

def SurfaceSlopeXAnalysisEnum():
	"""
	SURFACESLOPEXANALYSISENUM - Enum of SurfaceSlopeXAnalysis

	   Usage:
	      macro=SurfaceSlopeXAnalysisEnum()
	"""

	return StringToEnum('SurfaceSlopeXAnalysis')[0]

def SurfaceSlopeYAnalysisEnum():
	"""
	SURFACESLOPEYANALYSISENUM - Enum of SurfaceSlopeYAnalysis

	   Usage:
	      macro=SurfaceSlopeYAnalysisEnum()
	"""

	return StringToEnum('SurfaceSlopeYAnalysis')[0]

def ThermalAnalysisEnum():
	"""
	THERMALANALYSISENUM - Enum of ThermalAnalysis

	   Usage:
	      macro=ThermalAnalysisEnum()
	"""

	return StringToEnum('ThermalAnalysis')[0]

def ThermalSolutionEnum():
	"""
	THERMALSOLUTIONENUM - Enum of ThermalSolution

	   Usage:
	      macro=ThermalSolutionEnum()
	"""

	return StringToEnum('ThermalSolution')[0]

def TransientSolutionEnum():
	"""
	TRANSIENTSOLUTIONENUM - Enum of TransientSolution

	   Usage:
	      macro=TransientSolutionEnum()
	"""

	return StringToEnum('TransientSolution')[0]

def ApproximationEnum():
	"""
	APPROXIMATIONENUM - Enum of Approximation

	   Usage:
	      macro=ApproximationEnum()
	"""

	return StringToEnum('Approximation')[0]

def NoneApproximationEnum():
	"""
	NONEAPPROXIMATIONENUM - Enum of NoneApproximation

	   Usage:
	      macro=NoneApproximationEnum()
	"""

	return StringToEnum('NoneApproximation')[0]

def HutterApproximationEnum():
	"""
	HUTTERAPPROXIMATIONENUM - Enum of HutterApproximation

	   Usage:
	      macro=HutterApproximationEnum()
	"""

	return StringToEnum('HutterApproximation')[0]

def MacAyealApproximationEnum():
	"""
	MACAYEALAPPROXIMATIONENUM - Enum of MacAyealApproximation

	   Usage:
	      macro=MacAyealApproximationEnum()
	"""

	return StringToEnum('MacAyealApproximation')[0]

def MacAyealPattynApproximationEnum():
	"""
	MACAYEALPATTYNAPPROXIMATIONENUM - Enum of MacAyealPattynApproximation

	   Usage:
	      macro=MacAyealPattynApproximationEnum()
	"""

	return StringToEnum('MacAyealPattynApproximation')[0]

def MacAyealStokesApproximationEnum():
	"""
	MACAYEALSTOKESAPPROXIMATIONENUM - Enum of MacAyealStokesApproximation

	   Usage:
	      macro=MacAyealStokesApproximationEnum()
	"""

	return StringToEnum('MacAyealStokesApproximation')[0]

def L1L2ApproximationEnum():
	"""
	L1L2APPROXIMATIONENUM - Enum of L1L2Approximation

	   Usage:
	      macro=L1L2ApproximationEnum()
	"""

	return StringToEnum('L1L2Approximation')[0]

def PattynApproximationEnum():
	"""
	PATTYNAPPROXIMATIONENUM - Enum of PattynApproximation

	   Usage:
	      macro=PattynApproximationEnum()
	"""

	return StringToEnum('PattynApproximation')[0]

def PattynStokesApproximationEnum():
	"""
	PATTYNSTOKESAPPROXIMATIONENUM - Enum of PattynStokesApproximation

	   Usage:
	      macro=PattynStokesApproximationEnum()
	"""

	return StringToEnum('PattynStokesApproximation')[0]

def StokesApproximationEnum():
	"""
	STOKESAPPROXIMATIONENUM - Enum of StokesApproximation

	   Usage:
	      macro=StokesApproximationEnum()
	"""

	return StringToEnum('StokesApproximation')[0]

def ConstraintsEnum():
	"""
	CONSTRAINTSENUM - Enum of Constraints

	   Usage:
	      macro=ConstraintsEnum()
	"""

	return StringToEnum('Constraints')[0]

def LoadsEnum():
	"""
	LOADSENUM - Enum of Loads

	   Usage:
	      macro=LoadsEnum()
	"""

	return StringToEnum('Loads')[0]

def MaterialsEnum():
	"""
	MATERIALSENUM - Enum of Materials

	   Usage:
	      macro=MaterialsEnum()
	"""

	return StringToEnum('Materials')[0]

def NodesEnum():
	"""
	NODESENUM - Enum of Nodes

	   Usage:
	      macro=NodesEnum()
	"""

	return StringToEnum('Nodes')[0]

def ParametersEnum():
	"""
	PARAMETERSENUM - Enum of Parameters

	   Usage:
	      macro=ParametersEnum()
	"""

	return StringToEnum('Parameters')[0]

def VerticesEnum():
	"""
	VERTICESENUM - Enum of Vertices

	   Usage:
	      macro=VerticesEnum()
	"""

	return StringToEnum('Vertices')[0]

def ResultsEnum():
	"""
	RESULTSENUM - Enum of Results

	   Usage:
	      macro=ResultsEnum()
	"""

	return StringToEnum('Results')[0]

def GenericParamEnum():
	"""
	GENERICPARAMENUM - Enum of GenericParam

	   Usage:
	      macro=GenericParamEnum()
	"""

	return StringToEnum('GenericParam')[0]

def AdolcParamEnum():
	"""
	ADOLCPARAMENUM - Enum of AdolcParam

	   Usage:
	      macro=AdolcParamEnum()
	"""

	return StringToEnum('AdolcParam')[0]

def BoolInputEnum():
	"""
	BOOLINPUTENUM - Enum of BoolInput

	   Usage:
	      macro=BoolInputEnum()
	"""

	return StringToEnum('BoolInput')[0]

def BoolParamEnum():
	"""
	BOOLPARAMENUM - Enum of BoolParam

	   Usage:
	      macro=BoolParamEnum()
	"""

	return StringToEnum('BoolParam')[0]

def ContourEnum():
	"""
	CONTOURENUM - Enum of Contour

	   Usage:
	      macro=ContourEnum()
	"""

	return StringToEnum('Contour')[0]

def ControlInputEnum():
	"""
	CONTROLINPUTENUM - Enum of ControlInput

	   Usage:
	      macro=ControlInputEnum()
	"""

	return StringToEnum('ControlInput')[0]

def DatasetInputEnum():
	"""
	DATASETINPUTENUM - Enum of DatasetInput

	   Usage:
	      macro=DatasetInputEnum()
	"""

	return StringToEnum('DatasetInput')[0]

def DofIndexingEnum():
	"""
	DOFINDEXINGENUM - Enum of DofIndexing

	   Usage:
	      macro=DofIndexingEnum()
	"""

	return StringToEnum('DofIndexing')[0]

def DoubleInputEnum():
	"""
	DOUBLEINPUTENUM - Enum of DoubleInput

	   Usage:
	      macro=DoubleInputEnum()
	"""

	return StringToEnum('DoubleInput')[0]

def DataSetParamEnum():
	"""
	DATASETPARAMENUM - Enum of DataSetParam

	   Usage:
	      macro=DataSetParamEnum()
	"""

	return StringToEnum('DataSetParam')[0]

def DoubleMatArrayParamEnum():
	"""
	DOUBLEMATARRAYPARAMENUM - Enum of DoubleMatArrayParam

	   Usage:
	      macro=DoubleMatArrayParamEnum()
	"""

	return StringToEnum('DoubleMatArrayParam')[0]

def DoubleMatParamEnum():
	"""
	DOUBLEMATPARAMENUM - Enum of DoubleMatParam

	   Usage:
	      macro=DoubleMatParamEnum()
	"""

	return StringToEnum('DoubleMatParam')[0]

def DoubleParamEnum():
	"""
	DOUBLEPARAMENUM - Enum of DoubleParam

	   Usage:
	      macro=DoubleParamEnum()
	"""

	return StringToEnum('DoubleParam')[0]

def DoubleVecParamEnum():
	"""
	DOUBLEVECPARAMENUM - Enum of DoubleVecParam

	   Usage:
	      macro=DoubleVecParamEnum()
	"""

	return StringToEnum('DoubleVecParam')[0]

def ElementEnum():
	"""
	ELEMENTENUM - Enum of Element

	   Usage:
	      macro=ElementEnum()
	"""

	return StringToEnum('Element')[0]

def ElementResultEnum():
	"""
	ELEMENTRESULTENUM - Enum of ElementResult

	   Usage:
	      macro=ElementResultEnum()
	"""

	return StringToEnum('ElementResult')[0]

def ExternalResultEnum():
	"""
	EXTERNALRESULTENUM - Enum of ExternalResult

	   Usage:
	      macro=ExternalResultEnum()
	"""

	return StringToEnum('ExternalResult')[0]

def FileParamEnum():
	"""
	FILEPARAMENUM - Enum of FileParam

	   Usage:
	      macro=FileParamEnum()
	"""

	return StringToEnum('FileParam')[0]

def HookEnum():
	"""
	HOOKENUM - Enum of Hook

	   Usage:
	      macro=HookEnum()
	"""

	return StringToEnum('Hook')[0]

def IcefrontEnum():
	"""
	ICEFRONTENUM - Enum of Icefront

	   Usage:
	      macro=IcefrontEnum()
	"""

	return StringToEnum('Icefront')[0]

def InputEnum():
	"""
	INPUTENUM - Enum of Input

	   Usage:
	      macro=InputEnum()
	"""

	return StringToEnum('Input')[0]

def IntInputEnum():
	"""
	INTINPUTENUM - Enum of IntInput

	   Usage:
	      macro=IntInputEnum()
	"""

	return StringToEnum('IntInput')[0]

def IntParamEnum():
	"""
	INTPARAMENUM - Enum of IntParam

	   Usage:
	      macro=IntParamEnum()
	"""

	return StringToEnum('IntParam')[0]

def IntVecParamEnum():
	"""
	INTVECPARAMENUM - Enum of IntVecParam

	   Usage:
	      macro=IntVecParamEnum()
	"""

	return StringToEnum('IntVecParam')[0]

def TransientParamEnum():
	"""
	TRANSIENTPARAMENUM - Enum of TransientParam

	   Usage:
	      macro=TransientParamEnum()
	"""

	return StringToEnum('TransientParam')[0]

def MacAyeal2dIceFrontEnum():
	"""
	MACAYEAL2DICEFRONTENUM - Enum of MacAyeal2dIceFront

	   Usage:
	      macro=MacAyeal2dIceFrontEnum()
	"""

	return StringToEnum('MacAyeal2dIceFront')[0]

def MacAyeal3dIceFrontEnum():
	"""
	MACAYEAL3DICEFRONTENUM - Enum of MacAyeal3dIceFront

	   Usage:
	      macro=MacAyeal3dIceFrontEnum()
	"""

	return StringToEnum('MacAyeal3dIceFront')[0]

def MaticeEnum():
	"""
	MATICEENUM - Enum of Matice

	   Usage:
	      macro=MaticeEnum()
	"""

	return StringToEnum('Matice')[0]

def MatdamageiceEnum():
	"""
	MATDAMAGEICEENUM - Enum of Matdamageice

	   Usage:
	      macro=MatdamageiceEnum()
	"""

	return StringToEnum('Matdamageice')[0]

def MatparEnum():
	"""
	MATPARENUM - Enum of Matpar

	   Usage:
	      macro=MatparEnum()
	"""

	return StringToEnum('Matpar')[0]

def NodeEnum():
	"""
	NODEENUM - Enum of Node

	   Usage:
	      macro=NodeEnum()
	"""

	return StringToEnum('Node')[0]

def NumericalfluxEnum():
	"""
	NUMERICALFLUXENUM - Enum of Numericalflux

	   Usage:
	      macro=NumericalfluxEnum()
	"""

	return StringToEnum('Numericalflux')[0]

def ParamEnum():
	"""
	PARAMENUM - Enum of Param

	   Usage:
	      macro=ParamEnum()
	"""

	return StringToEnum('Param')[0]

def L1L2IceFrontEnum():
	"""
	L1L2ICEFRONTENUM - Enum of L1L2IceFront

	   Usage:
	      macro=L1L2IceFrontEnum()
	"""

	return StringToEnum('L1L2IceFront')[0]

def PattynIceFrontEnum():
	"""
	PATTYNICEFRONTENUM - Enum of PattynIceFront

	   Usage:
	      macro=PattynIceFrontEnum()
	"""

	return StringToEnum('PattynIceFront')[0]

def PengridEnum():
	"""
	PENGRIDENUM - Enum of Pengrid

	   Usage:
	      macro=PengridEnum()
	"""

	return StringToEnum('Pengrid')[0]

def PenpairEnum():
	"""
	PENPAIRENUM - Enum of Penpair

	   Usage:
	      macro=PenpairEnum()
	"""

	return StringToEnum('Penpair')[0]

def PentaEnum():
	"""
	PENTAENUM - Enum of Penta

	   Usage:
	      macro=PentaEnum()
	"""

	return StringToEnum('Penta')[0]

def PentaP1InputEnum():
	"""
	PENTAP1INPUTENUM - Enum of PentaP1Input

	   Usage:
	      macro=PentaP1InputEnum()
	"""

	return StringToEnum('PentaP1Input')[0]

def ProfilerEnum():
	"""
	PROFILERENUM - Enum of Profiler

	   Usage:
	      macro=ProfilerEnum()
	"""

	return StringToEnum('Profiler')[0]

def MatrixParamEnum():
	"""
	MATRIXPARAMENUM - Enum of MatrixParam

	   Usage:
	      macro=MatrixParamEnum()
	"""

	return StringToEnum('MatrixParam')[0]

def VectorParamEnum():
	"""
	VECTORPARAMENUM - Enum of VectorParam

	   Usage:
	      macro=VectorParamEnum()
	"""

	return StringToEnum('VectorParam')[0]

def RiftfrontEnum():
	"""
	RIFTFRONTENUM - Enum of Riftfront

	   Usage:
	      macro=RiftfrontEnum()
	"""

	return StringToEnum('Riftfront')[0]

def SegmentEnum():
	"""
	SEGMENTENUM - Enum of Segment

	   Usage:
	      macro=SegmentEnum()
	"""

	return StringToEnum('Segment')[0]

def SegmentRiftfrontEnum():
	"""
	SEGMENTRIFTFRONTENUM - Enum of SegmentRiftfront

	   Usage:
	      macro=SegmentRiftfrontEnum()
	"""

	return StringToEnum('SegmentRiftfront')[0]

def SpcDynamicEnum():
	"""
	SPCDYNAMICENUM - Enum of SpcDynamic

	   Usage:
	      macro=SpcDynamicEnum()
	"""

	return StringToEnum('SpcDynamic')[0]

def SpcStaticEnum():
	"""
	SPCSTATICENUM - Enum of SpcStatic

	   Usage:
	      macro=SpcStaticEnum()
	"""

	return StringToEnum('SpcStatic')[0]

def SpcTransientEnum():
	"""
	SPCTRANSIENTENUM - Enum of SpcTransient

	   Usage:
	      macro=SpcTransientEnum()
	"""

	return StringToEnum('SpcTransient')[0]

def StokesIceFrontEnum():
	"""
	STOKESICEFRONTENUM - Enum of StokesIceFront

	   Usage:
	      macro=StokesIceFrontEnum()
	"""

	return StringToEnum('StokesIceFront')[0]

def StringArrayParamEnum():
	"""
	STRINGARRAYPARAMENUM - Enum of StringArrayParam

	   Usage:
	      macro=StringArrayParamEnum()
	"""

	return StringToEnum('StringArrayParam')[0]

def StringParamEnum():
	"""
	STRINGPARAMENUM - Enum of StringParam

	   Usage:
	      macro=StringParamEnum()
	"""

	return StringToEnum('StringParam')[0]

def TriaEnum():
	"""
	TRIAENUM - Enum of Tria

	   Usage:
	      macro=TriaEnum()
	"""

	return StringToEnum('Tria')[0]

def TriaP1InputEnum():
	"""
	TRIAP1INPUTENUM - Enum of TriaP1Input

	   Usage:
	      macro=TriaP1InputEnum()
	"""

	return StringToEnum('TriaP1Input')[0]

def VertexEnum():
	"""
	VERTEXENUM - Enum of Vertex

	   Usage:
	      macro=VertexEnum()
	"""

	return StringToEnum('Vertex')[0]

def AirEnum():
	"""
	AIRENUM - Enum of Air

	   Usage:
	      macro=AirEnum()
	"""

	return StringToEnum('Air')[0]

def IceEnum():
	"""
	ICEENUM - Enum of Ice

	   Usage:
	      macro=IceEnum()
	"""

	return StringToEnum('Ice')[0]

def MelangeEnum():
	"""
	MELANGEENUM - Enum of Melange

	   Usage:
	      macro=MelangeEnum()
	"""

	return StringToEnum('Melange')[0]

def WaterEnum():
	"""
	WATERENUM - Enum of Water

	   Usage:
	      macro=WaterEnum()
	"""

	return StringToEnum('Water')[0]

def ClosedEnum():
	"""
	CLOSEDENUM - Enum of Closed

	   Usage:
	      macro=ClosedEnum()
	"""

	return StringToEnum('Closed')[0]

def FreeEnum():
	"""
	FREEENUM - Enum of Free

	   Usage:
	      macro=FreeEnum()
	"""

	return StringToEnum('Free')[0]

def OpenEnum():
	"""
	OPENENUM - Enum of Open

	   Usage:
	      macro=OpenEnum()
	"""

	return StringToEnum('Open')[0]

def AdjointpEnum():
	"""
	ADJOINTPENUM - Enum of Adjointp

	   Usage:
	      macro=AdjointpEnum()
	"""

	return StringToEnum('Adjointp')[0]

def AdjointxEnum():
	"""
	ADJOINTXENUM - Enum of Adjointx

	   Usage:
	      macro=AdjointxEnum()
	"""

	return StringToEnum('Adjointx')[0]

def AdjointyEnum():
	"""
	ADJOINTYENUM - Enum of Adjointy

	   Usage:
	      macro=AdjointyEnum()
	"""

	return StringToEnum('Adjointy')[0]

def AdjointzEnum():
	"""
	ADJOINTZENUM - Enum of Adjointz

	   Usage:
	      macro=AdjointzEnum()
	"""

	return StringToEnum('Adjointz')[0]

def BedSlopeXEnum():
	"""
	BEDSLOPEXENUM - Enum of BedSlopeX

	   Usage:
	      macro=BedSlopeXEnum()
	"""

	return StringToEnum('BedSlopeX')[0]

def BedSlopeYEnum():
	"""
	BEDSLOPEYENUM - Enum of BedSlopeY

	   Usage:
	      macro=BedSlopeYEnum()
	"""

	return StringToEnum('BedSlopeY')[0]

def BoundaryEnum():
	"""
	BOUNDARYENUM - Enum of Boundary

	   Usage:
	      macro=BoundaryEnum()
	"""

	return StringToEnum('Boundary')[0]

def ConstantEnum():
	"""
	CONSTANTENUM - Enum of Constant

	   Usage:
	      macro=ConstantEnum()
	"""

	return StringToEnum('Constant')[0]

def ConvergedEnum():
	"""
	CONVERGEDENUM - Enum of Converged

	   Usage:
	      macro=ConvergedEnum()
	"""

	return StringToEnum('Converged')[0]

def ExtToIuEnum():
	"""
	EXTTOIUENUM - Enum of ExtToIu

	   Usage:
	      macro=ExtToIuEnum()
	"""

	return StringToEnum('ExtToIu')[0]

def FillEnum():
	"""
	FILLENUM - Enum of Fill

	   Usage:
	      macro=FillEnum()
	"""

	return StringToEnum('Fill')[0]

def FractionIncrementEnum():
	"""
	FRACTIONINCREMENTENUM - Enum of FractionIncrement

	   Usage:
	      macro=FractionIncrementEnum()
	"""

	return StringToEnum('FractionIncrement')[0]

def FrictionEnum():
	"""
	FRICTIONENUM - Enum of Friction

	   Usage:
	      macro=FrictionEnum()
	"""

	return StringToEnum('Friction')[0]

def GroundinglineMeltingRateEnum():
	"""
	GROUNDINGLINEMELTINGRATEENUM - Enum of GroundinglineMeltingRate

	   Usage:
	      macro=GroundinglineMeltingRateEnum()
	"""

	return StringToEnum('GroundinglineMeltingRate')[0]

def InternalEnum():
	"""
	INTERNALENUM - Enum of Internal

	   Usage:
	      macro=InternalEnum()
	"""

	return StringToEnum('Internal')[0]

def IuToExtEnum():
	"""
	IUTOEXTENUM - Enum of IuToExt

	   Usage:
	      macro=IuToExtEnum()
	"""

	return StringToEnum('IuToExt')[0]

def MassFluxEnum():
	"""
	MASSFLUXENUM - Enum of MassFlux

	   Usage:
	      macro=MassFluxEnum()
	"""

	return StringToEnum('MassFlux')[0]

def MaxPenetrationEnum():
	"""
	MAXPENETRATIONENUM - Enum of MaxPenetration

	   Usage:
	      macro=MaxPenetrationEnum()
	"""

	return StringToEnum('MaxPenetration')[0]

def MeltingOffsetEnum():
	"""
	MELTINGOFFSETENUM - Enum of MeltingOffset

	   Usage:
	      macro=MeltingOffsetEnum()
	"""

	return StringToEnum('MeltingOffset')[0]

def MisfitEnum():
	"""
	MISFITENUM - Enum of Misfit

	   Usage:
	      macro=MisfitEnum()
	"""

	return StringToEnum('Misfit')[0]

def NumberNodeToElementConnectivityEnum():
	"""
	NUMBERNODETOELEMENTCONNECTIVITYENUM - Enum of NumberNodeToElementConnectivity

	   Usage:
	      macro=NumberNodeToElementConnectivityEnum()
	"""

	return StringToEnum('NumberNodeToElementConnectivity')[0]

def PressureEnum():
	"""
	PRESSUREENUM - Enum of Pressure

	   Usage:
	      macro=PressureEnum()
	"""

	return StringToEnum('Pressure')[0]

def PressurePicardEnum():
	"""
	PRESSUREPICARDENUM - Enum of PressurePicard

	   Usage:
	      macro=PressurePicardEnum()
	"""

	return StringToEnum('PressurePicard')[0]

def QmuPressureEnum():
	"""
	QMUPRESSUREENUM - Enum of QmuPressure

	   Usage:
	      macro=QmuPressureEnum()
	"""

	return StringToEnum('QmuPressure')[0]

def QmuVxEnum():
	"""
	QMUVXENUM - Enum of QmuVx

	   Usage:
	      macro=QmuVxEnum()
	"""

	return StringToEnum('QmuVx')[0]

def QmuVyEnum():
	"""
	QMUVYENUM - Enum of QmuVy

	   Usage:
	      macro=QmuVyEnum()
	"""

	return StringToEnum('QmuVy')[0]

def QmuVzEnum():
	"""
	QMUVZENUM - Enum of QmuVz

	   Usage:
	      macro=QmuVzEnum()
	"""

	return StringToEnum('QmuVz')[0]

def QmuThicknessEnum():
	"""
	QMUTHICKNESSENUM - Enum of QmuThickness

	   Usage:
	      macro=QmuThicknessEnum()
	"""

	return StringToEnum('QmuThickness')[0]

def QmuBedEnum():
	"""
	QMUBEDENUM - Enum of QmuBed

	   Usage:
	      macro=QmuBedEnum()
	"""

	return StringToEnum('QmuBed')[0]

def QmuSurfaceEnum():
	"""
	QMUSURFACEENUM - Enum of QmuSurface

	   Usage:
	      macro=QmuSurfaceEnum()
	"""

	return StringToEnum('QmuSurface')[0]

def QmuMeltingEnum():
	"""
	QMUMELTINGENUM - Enum of QmuMelting

	   Usage:
	      macro=QmuMeltingEnum()
	"""

	return StringToEnum('QmuMelting')[0]

def ResetPenaltiesEnum():
	"""
	RESETPENALTIESENUM - Enum of ResetPenalties

	   Usage:
	      macro=ResetPenaltiesEnum()
	"""

	return StringToEnum('ResetPenalties')[0]

def SegmentOnIceShelfEnum():
	"""
	SEGMENTONICESHELFENUM - Enum of SegmentOnIceShelf

	   Usage:
	      macro=SegmentOnIceShelfEnum()
	"""

	return StringToEnum('SegmentOnIceShelf')[0]

def SurfaceAbsVelMisfitEnum():
	"""
	SURFACEABSVELMISFITENUM - Enum of SurfaceAbsVelMisfit

	   Usage:
	      macro=SurfaceAbsVelMisfitEnum()
	"""

	return StringToEnum('SurfaceAbsVelMisfit')[0]

def SurfaceAreaEnum():
	"""
	SURFACEAREAENUM - Enum of SurfaceArea

	   Usage:
	      macro=SurfaceAreaEnum()
	"""

	return StringToEnum('SurfaceArea')[0]

def SurfaceAverageVelMisfitEnum():
	"""
	SURFACEAVERAGEVELMISFITENUM - Enum of SurfaceAverageVelMisfit

	   Usage:
	      macro=SurfaceAverageVelMisfitEnum()
	"""

	return StringToEnum('SurfaceAverageVelMisfit')[0]

def SurfaceLogVelMisfitEnum():
	"""
	SURFACELOGVELMISFITENUM - Enum of SurfaceLogVelMisfit

	   Usage:
	      macro=SurfaceLogVelMisfitEnum()
	"""

	return StringToEnum('SurfaceLogVelMisfit')[0]

def SurfaceLogVxVyMisfitEnum():
	"""
	SURFACELOGVXVYMISFITENUM - Enum of SurfaceLogVxVyMisfit

	   Usage:
	      macro=SurfaceLogVxVyMisfitEnum()
	"""

	return StringToEnum('SurfaceLogVxVyMisfit')[0]

def SurfaceRelVelMisfitEnum():
	"""
	SURFACERELVELMISFITENUM - Enum of SurfaceRelVelMisfit

	   Usage:
	      macro=SurfaceRelVelMisfitEnum()
	"""

	return StringToEnum('SurfaceRelVelMisfit')[0]

def SurfaceSlopeXEnum():
	"""
	SURFACESLOPEXENUM - Enum of SurfaceSlopeX

	   Usage:
	      macro=SurfaceSlopeXEnum()
	"""

	return StringToEnum('SurfaceSlopeX')[0]

def SurfaceSlopeYEnum():
	"""
	SURFACESLOPEYENUM - Enum of SurfaceSlopeY

	   Usage:
	      macro=SurfaceSlopeYEnum()
	"""

	return StringToEnum('SurfaceSlopeY')[0]

def TemperatureEnum():
	"""
	TEMPERATUREENUM - Enum of Temperature

	   Usage:
	      macro=TemperatureEnum()
	"""

	return StringToEnum('Temperature')[0]

def TemperatureOldEnum():
	"""
	TEMPERATUREOLDENUM - Enum of TemperatureOld

	   Usage:
	      macro=TemperatureOldEnum()
	"""

	return StringToEnum('TemperatureOld')[0]

def TemperaturePicardEnum():
	"""
	TEMPERATUREPICARDENUM - Enum of TemperaturePicard

	   Usage:
	      macro=TemperaturePicardEnum()
	"""

	return StringToEnum('TemperaturePicard')[0]

def TemperatureSurfaceEnum():
	"""
	TEMPERATURESURFACEENUM - Enum of TemperatureSurface

	   Usage:
	      macro=TemperatureSurfaceEnum()
	"""

	return StringToEnum('TemperatureSurface')[0]

def TemperatureBasalEnum():
	"""
	TEMPERATUREBASALENUM - Enum of TemperatureBasal

	   Usage:
	      macro=TemperatureBasalEnum()
	"""

	return StringToEnum('TemperatureBasal')[0]

def ThicknessAbsMisfitEnum():
	"""
	THICKNESSABSMISFITENUM - Enum of ThicknessAbsMisfit

	   Usage:
	      macro=ThicknessAbsMisfitEnum()
	"""

	return StringToEnum('ThicknessAbsMisfit')[0]

def TypeEnum():
	"""
	TYPEENUM - Enum of Type

	   Usage:
	      macro=TypeEnum()
	"""

	return StringToEnum('Type')[0]

def VelEnum():
	"""
	VELENUM - Enum of Vel

	   Usage:
	      macro=VelEnum()
	"""

	return StringToEnum('Vel')[0]

def VelocityEnum():
	"""
	VELOCITYENUM - Enum of Velocity

	   Usage:
	      macro=VelocityEnum()
	"""

	return StringToEnum('Velocity')[0]

def VxAverageEnum():
	"""
	VXAVERAGEENUM - Enum of VxAverage

	   Usage:
	      macro=VxAverageEnum()
	"""

	return StringToEnum('VxAverage')[0]

def VxEnum():
	"""
	VXENUM - Enum of Vx

	   Usage:
	      macro=VxEnum()
	"""

	return StringToEnum('Vx')[0]

def VxPicardEnum():
	"""
	VXPICARDENUM - Enum of VxPicard

	   Usage:
	      macro=VxPicardEnum()
	"""

	return StringToEnum('VxPicard')[0]

def VyAverageEnum():
	"""
	VYAVERAGEENUM - Enum of VyAverage

	   Usage:
	      macro=VyAverageEnum()
	"""

	return StringToEnum('VyAverage')[0]

def VyEnum():
	"""
	VYENUM - Enum of Vy

	   Usage:
	      macro=VyEnum()
	"""

	return StringToEnum('Vy')[0]

def VyPicardEnum():
	"""
	VYPICARDENUM - Enum of VyPicard

	   Usage:
	      macro=VyPicardEnum()
	"""

	return StringToEnum('VyPicard')[0]

def VzEnum():
	"""
	VZENUM - Enum of Vz

	   Usage:
	      macro=VzEnum()
	"""

	return StringToEnum('Vz')[0]

def VzMacAyealEnum():
	"""
	VZMACAYEALENUM - Enum of VzMacAyeal

	   Usage:
	      macro=VzMacAyealEnum()
	"""

	return StringToEnum('VzMacAyeal')[0]

def VzPattynEnum():
	"""
	VZPATTYNENUM - Enum of VzPattyn

	   Usage:
	      macro=VzPattynEnum()
	"""

	return StringToEnum('VzPattyn')[0]

def VzPicardEnum():
	"""
	VZPICARDENUM - Enum of VzPicard

	   Usage:
	      macro=VzPicardEnum()
	"""

	return StringToEnum('VzPicard')[0]

def VzStokesEnum():
	"""
	VZSTOKESENUM - Enum of VzStokes

	   Usage:
	      macro=VzStokesEnum()
	"""

	return StringToEnum('VzStokes')[0]

def VxMeshEnum():
	"""
	VXMESHENUM - Enum of VxMesh

	   Usage:
	      macro=VxMeshEnum()
	"""

	return StringToEnum('VxMesh')[0]

def VyMeshEnum():
	"""
	VYMESHENUM - Enum of VyMesh

	   Usage:
	      macro=VyMeshEnum()
	"""

	return StringToEnum('VyMesh')[0]

def VzMeshEnum():
	"""
	VZMESHENUM - Enum of VzMesh

	   Usage:
	      macro=VzMeshEnum()
	"""

	return StringToEnum('VzMesh')[0]

def EnthalpyEnum():
	"""
	ENTHALPYENUM - Enum of Enthalpy

	   Usage:
	      macro=EnthalpyEnum()
	"""

	return StringToEnum('Enthalpy')[0]

def EnthalpyPicardEnum():
	"""
	ENTHALPYPICARDENUM - Enum of EnthalpyPicard

	   Usage:
	      macro=EnthalpyPicardEnum()
	"""

	return StringToEnum('EnthalpyPicard')[0]

def ThicknessAbsGradientEnum():
	"""
	THICKNESSABSGRADIENTENUM - Enum of ThicknessAbsGradient

	   Usage:
	      macro=ThicknessAbsGradientEnum()
	"""

	return StringToEnum('ThicknessAbsGradient')[0]

def ThicknessAlongGradientEnum():
	"""
	THICKNESSALONGGRADIENTENUM - Enum of ThicknessAlongGradient

	   Usage:
	      macro=ThicknessAlongGradientEnum()
	"""

	return StringToEnum('ThicknessAlongGradient')[0]

def ThicknessAcrossGradientEnum():
	"""
	THICKNESSACROSSGRADIENTENUM - Enum of ThicknessAcrossGradient

	   Usage:
	      macro=ThicknessAcrossGradientEnum()
	"""

	return StringToEnum('ThicknessAcrossGradient')[0]

def StepResponsesEnum():
	"""
	STEPRESPONSESENUM - Enum of StepResponses

	   Usage:
	      macro=StepResponsesEnum()
	"""

	return StringToEnum('StepResponses')[0]

def IntMatParamEnum():
	"""
	INTMATPARAMENUM - Enum of IntMatParam

	   Usage:
	      macro=IntMatParamEnum()
	"""

	return StringToEnum('IntMatParam')[0]

def RheologyBbarAbsGradientEnum():
	"""
	RHEOLOGYBBARABSGRADIENTENUM - Enum of RheologyBbarAbsGradient

	   Usage:
	      macro=RheologyBbarAbsGradientEnum()
	"""

	return StringToEnum('RheologyBbarAbsGradient')[0]

def DragCoefficientAbsGradientEnum():
	"""
	DRAGCOEFFICIENTABSGRADIENTENUM - Enum of DragCoefficientAbsGradient

	   Usage:
	      macro=DragCoefficientAbsGradientEnum()
	"""

	return StringToEnum('DragCoefficientAbsGradient')[0]

def TransientInputEnum():
	"""
	TRANSIENTINPUTENUM - Enum of TransientInput

	   Usage:
	      macro=TransientInputEnum()
	"""

	return StringToEnum('TransientInput')[0]

def OutputfilenameEnum():
	"""
	OUTPUTFILENAMEENUM - Enum of Outputfilename

	   Usage:
	      macro=OutputfilenameEnum()
	"""

	return StringToEnum('Outputfilename')[0]

def WaterfractionEnum():
	"""
	WATERFRACTIONENUM - Enum of Waterfraction

	   Usage:
	      macro=WaterfractionEnum()
	"""

	return StringToEnum('Waterfraction')[0]

def WatercolumnEnum():
	"""
	WATERCOLUMNENUM - Enum of Watercolumn

	   Usage:
	      macro=WatercolumnEnum()
	"""

	return StringToEnum('Watercolumn')[0]

def BasalFrictionEnum():
	"""
	BASALFRICTIONENUM - Enum of BasalFriction

	   Usage:
	      macro=BasalFrictionEnum()
	"""

	return StringToEnum('BasalFriction')[0]

def ViscousHeatingEnum():
	"""
	VISCOUSHEATINGENUM - Enum of ViscousHeating

	   Usage:
	      macro=ViscousHeatingEnum()
	"""

	return StringToEnum('ViscousHeating')[0]

def QmuTemperatureEnum():
	"""
	QMUTEMPERATUREENUM - Enum of QmuTemperature

	   Usage:
	      macro=QmuTemperatureEnum()
	"""

	return StringToEnum('QmuTemperature')[0]

def HydrologyWaterVxEnum():
	"""
	HYDROLOGYWATERVXENUM - Enum of HydrologyWaterVx

	   Usage:
	      macro=HydrologyWaterVxEnum()
	"""

	return StringToEnum('HydrologyWaterVx')[0]

def HydrologyWaterVyEnum():
	"""
	HYDROLOGYWATERVYENUM - Enum of HydrologyWaterVy

	   Usage:
	      macro=HydrologyWaterVyEnum()
	"""

	return StringToEnum('HydrologyWaterVy')[0]

def StressTensorEnum():
	"""
	STRESSTENSORENUM - Enum of StressTensor

	   Usage:
	      macro=StressTensorEnum()
	"""

	return StringToEnum('StressTensor')[0]

def StressTensorxxEnum():
	"""
	STRESSTENSORXXENUM - Enum of StressTensorxx

	   Usage:
	      macro=StressTensorxxEnum()
	"""

	return StringToEnum('StressTensorxx')[0]

def StressTensorxyEnum():
	"""
	STRESSTENSORXYENUM - Enum of StressTensorxy

	   Usage:
	      macro=StressTensorxyEnum()
	"""

	return StringToEnum('StressTensorxy')[0]

def StressTensorxzEnum():
	"""
	STRESSTENSORXZENUM - Enum of StressTensorxz

	   Usage:
	      macro=StressTensorxzEnum()
	"""

	return StringToEnum('StressTensorxz')[0]

def StressTensoryyEnum():
	"""
	STRESSTENSORYYENUM - Enum of StressTensoryy

	   Usage:
	      macro=StressTensoryyEnum()
	"""

	return StringToEnum('StressTensoryy')[0]

def StressTensoryzEnum():
	"""
	STRESSTENSORYZENUM - Enum of StressTensoryz

	   Usage:
	      macro=StressTensoryzEnum()
	"""

	return StringToEnum('StressTensoryz')[0]

def StressTensorzzEnum():
	"""
	STRESSTENSORZZENUM - Enum of StressTensorzz

	   Usage:
	      macro=StressTensorzzEnum()
	"""

	return StringToEnum('StressTensorzz')[0]

def P0Enum():
	"""
	P0ENUM - Enum of P0

	   Usage:
	      macro=P0Enum()
	"""

	return StringToEnum('P0')[0]

def P1Enum():
	"""
	P1ENUM - Enum of P1

	   Usage:
	      macro=P1Enum()
	"""

	return StringToEnum('P1')[0]

def P1DGEnum():
	"""
	P1DGENUM - Enum of P1DG

	   Usage:
	      macro=P1DGEnum()
	"""

	return StringToEnum('P1DG')[0]

def SaveResultsEnum():
	"""
	SAVERESULTSENUM - Enum of SaveResults

	   Usage:
	      macro=SaveResultsEnum()
	"""

	return StringToEnum('SaveResults')[0]

def BoolElementResultEnum():
	"""
	BOOLELEMENTRESULTENUM - Enum of BoolElementResult

	   Usage:
	      macro=BoolElementResultEnum()
	"""

	return StringToEnum('BoolElementResult')[0]

def BoolExternalResultEnum():
	"""
	BOOLEXTERNALRESULTENUM - Enum of BoolExternalResult

	   Usage:
	      macro=BoolExternalResultEnum()
	"""

	return StringToEnum('BoolExternalResult')[0]

def DoubleElementResultEnum():
	"""
	DOUBLEELEMENTRESULTENUM - Enum of DoubleElementResult

	   Usage:
	      macro=DoubleElementResultEnum()
	"""

	return StringToEnum('DoubleElementResult')[0]

def DoubleExternalResultEnum():
	"""
	DOUBLEEXTERNALRESULTENUM - Enum of DoubleExternalResult

	   Usage:
	      macro=DoubleExternalResultEnum()
	"""

	return StringToEnum('DoubleExternalResult')[0]

def DoubleMatExternalResultEnum():
	"""
	DOUBLEMATEXTERNALRESULTENUM - Enum of DoubleMatExternalResult

	   Usage:
	      macro=DoubleMatExternalResultEnum()
	"""

	return StringToEnum('DoubleMatExternalResult')[0]

def DoubleVecExternalResultEnum():
	"""
	DOUBLEVECEXTERNALRESULTENUM - Enum of DoubleVecExternalResult

	   Usage:
	      macro=DoubleVecExternalResultEnum()
	"""

	return StringToEnum('DoubleVecExternalResult')[0]

def IntExternalResultEnum():
	"""
	INTEXTERNALRESULTENUM - Enum of IntExternalResult

	   Usage:
	      macro=IntExternalResultEnum()
	"""

	return StringToEnum('IntExternalResult')[0]

def JEnum():
	"""
	JENUM - Enum of J

	   Usage:
	      macro=JEnum()
	"""

	return StringToEnum('J')[0]

def PatchEnum():
	"""
	PATCHENUM - Enum of Patch

	   Usage:
	      macro=PatchEnum()
	"""

	return StringToEnum('Patch')[0]

def PatchNodesEnum():
	"""
	PATCHNODESENUM - Enum of PatchNodes

	   Usage:
	      macro=PatchNodesEnum()
	"""

	return StringToEnum('PatchNodes')[0]

def PatchVerticesEnum():
	"""
	PATCHVERTICESENUM - Enum of PatchVertices

	   Usage:
	      macro=PatchVerticesEnum()
	"""

	return StringToEnum('PatchVertices')[0]

def PentaP1ElementResultEnum():
	"""
	PENTAP1ELEMENTRESULTENUM - Enum of PentaP1ElementResult

	   Usage:
	      macro=PentaP1ElementResultEnum()
	"""

	return StringToEnum('PentaP1ElementResult')[0]

def PetscVecExternalResultEnum():
	"""
	PETSCVECEXTERNALRESULTENUM - Enum of PetscVecExternalResult

	   Usage:
	      macro=PetscVecExternalResultEnum()
	"""

	return StringToEnum('PetscVecExternalResult')[0]

def StringExternalResultEnum():
	"""
	STRINGEXTERNALRESULTENUM - Enum of StringExternalResult

	   Usage:
	      macro=StringExternalResultEnum()
	"""

	return StringToEnum('StringExternalResult')[0]

def StepEnum():
	"""
	STEPENUM - Enum of Step

	   Usage:
	      macro=StepEnum()
	"""

	return StringToEnum('Step')[0]

def TimeEnum():
	"""
	TIMEENUM - Enum of Time

	   Usage:
	      macro=TimeEnum()
	"""

	return StringToEnum('Time')[0]

def TriaP1ElementResultEnum():
	"""
	TRIAP1ELEMENTRESULTENUM - Enum of TriaP1ElementResult

	   Usage:
	      macro=TriaP1ElementResultEnum()
	"""

	return StringToEnum('TriaP1ElementResult')[0]

def WaterColumnOldEnum():
	"""
	WATERCOLUMNOLDENUM - Enum of WaterColumnOld

	   Usage:
	      macro=WaterColumnOldEnum()
	"""

	return StringToEnum('WaterColumnOld')[0]

def MinVelEnum():
	"""
	MINVELENUM - Enum of MinVel

	   Usage:
	      macro=MinVelEnum()
	"""

	return StringToEnum('MinVel')[0]

def MaxVelEnum():
	"""
	MAXVELENUM - Enum of MaxVel

	   Usage:
	      macro=MaxVelEnum()
	"""

	return StringToEnum('MaxVel')[0]

def MinVxEnum():
	"""
	MINVXENUM - Enum of MinVx

	   Usage:
	      macro=MinVxEnum()
	"""

	return StringToEnum('MinVx')[0]

def MaxVxEnum():
	"""
	MAXVXENUM - Enum of MaxVx

	   Usage:
	      macro=MaxVxEnum()
	"""

	return StringToEnum('MaxVx')[0]

def MaxAbsVxEnum():
	"""
	MAXABSVXENUM - Enum of MaxAbsVx

	   Usage:
	      macro=MaxAbsVxEnum()
	"""

	return StringToEnum('MaxAbsVx')[0]

def MinVyEnum():
	"""
	MINVYENUM - Enum of MinVy

	   Usage:
	      macro=MinVyEnum()
	"""

	return StringToEnum('MinVy')[0]

def MaxVyEnum():
	"""
	MAXVYENUM - Enum of MaxVy

	   Usage:
	      macro=MaxVyEnum()
	"""

	return StringToEnum('MaxVy')[0]

def MaxAbsVyEnum():
	"""
	MAXABSVYENUM - Enum of MaxAbsVy

	   Usage:
	      macro=MaxAbsVyEnum()
	"""

	return StringToEnum('MaxAbsVy')[0]

def MinVzEnum():
	"""
	MINVZENUM - Enum of MinVz

	   Usage:
	      macro=MinVzEnum()
	"""

	return StringToEnum('MinVz')[0]

def MaxVzEnum():
	"""
	MAXVZENUM - Enum of MaxVz

	   Usage:
	      macro=MaxVzEnum()
	"""

	return StringToEnum('MaxVz')[0]

def MaxAbsVzEnum():
	"""
	MAXABSVZENUM - Enum of MaxAbsVz

	   Usage:
	      macro=MaxAbsVzEnum()
	"""

	return StringToEnum('MaxAbsVz')[0]

def IceVolumeEnum():
	"""
	ICEVOLUMEENUM - Enum of IceVolume

	   Usage:
	      macro=IceVolumeEnum()
	"""

	return StringToEnum('IceVolume')[0]

def TotalSmbEnum():
	"""
	TOTALSMBENUM - Enum of TotalSmb

	   Usage:
	      macro=TotalSmbEnum()
	"""

	return StringToEnum('TotalSmb')[0]

def RelativeEnum():
	"""
	RELATIVEENUM - Enum of Relative

	   Usage:
	      macro=RelativeEnum()
	"""

	return StringToEnum('Relative')[0]

def AbsoluteEnum():
	"""
	ABSOLUTEENUM - Enum of Absolute

	   Usage:
	      macro=AbsoluteEnum()
	"""

	return StringToEnum('Absolute')[0]

def IncrementalEnum():
	"""
	INCREMENTALENUM - Enum of Incremental

	   Usage:
	      macro=IncrementalEnum()
	"""

	return StringToEnum('Incremental')[0]

def AgressiveMigrationEnum():
	"""
	AGRESSIVEMIGRATIONENUM - Enum of AgressiveMigration

	   Usage:
	      macro=AgressiveMigrationEnum()
	"""

	return StringToEnum('AgressiveMigration')[0]

def NoneEnum():
	"""
	NONEENUM - Enum of None

	   Usage:
	      macro=NoneEnum()
	"""

	return StringToEnum('None')[0]

def SoftMigrationEnum():
	"""
	SOFTMIGRATIONENUM - Enum of SoftMigration

	   Usage:
	      macro=SoftMigrationEnum()
	"""

	return StringToEnum('SoftMigration')[0]

def StokesSolverEnum():
	"""
	STOKESSOLVERENUM - Enum of StokesSolver

	   Usage:
	      macro=StokesSolverEnum()
	"""

	return StringToEnum('StokesSolver')[0]

def AdjointEnum():
	"""
	ADJOINTENUM - Enum of Adjoint

	   Usage:
	      macro=AdjointEnum()
	"""

	return StringToEnum('Adjoint')[0]

def ColinearEnum():
	"""
	COLINEARENUM - Enum of Colinear

	   Usage:
	      macro=ColinearEnum()
	"""

	return StringToEnum('Colinear')[0]

def ControlSteadyEnum():
	"""
	CONTROLSTEADYENUM - Enum of ControlSteady

	   Usage:
	      macro=ControlSteadyEnum()
	"""

	return StringToEnum('ControlSteady')[0]

def FsetEnum():
	"""
	FSETENUM - Enum of Fset

	   Usage:
	      macro=FsetEnum()
	"""

	return StringToEnum('Fset')[0]

def Gradient1Enum():
	"""
	GRADIENT1ENUM - Enum of Gradient1

	   Usage:
	      macro=Gradient1Enum()
	"""

	return StringToEnum('Gradient1')[0]

def Gradient2Enum():
	"""
	GRADIENT2ENUM - Enum of Gradient2

	   Usage:
	      macro=Gradient2Enum()
	"""

	return StringToEnum('Gradient2')[0]

def Gradient3Enum():
	"""
	GRADIENT3ENUM - Enum of Gradient3

	   Usage:
	      macro=Gradient3Enum()
	"""

	return StringToEnum('Gradient3')[0]

def GradientEnum():
	"""
	GRADIENTENUM - Enum of Gradient

	   Usage:
	      macro=GradientEnum()
	"""

	return StringToEnum('Gradient')[0]

def GroundinglineMigrationEnum():
	"""
	GROUNDINGLINEMIGRATIONENUM - Enum of GroundinglineMigration

	   Usage:
	      macro=GroundinglineMigrationEnum()
	"""

	return StringToEnum('GroundinglineMigration')[0]

def GsetEnum():
	"""
	GSETENUM - Enum of Gset

	   Usage:
	      macro=GsetEnum()
	"""

	return StringToEnum('Gset')[0]

def IndexEnum():
	"""
	INDEXENUM - Enum of Index

	   Usage:
	      macro=IndexEnum()
	"""

	return StringToEnum('Index')[0]

def IndexedEnum():
	"""
	INDEXEDENUM - Enum of Indexed

	   Usage:
	      macro=IndexedEnum()
	"""

	return StringToEnum('Indexed')[0]

def IntersectEnum():
	"""
	INTERSECTENUM - Enum of Intersect

	   Usage:
	      macro=IntersectEnum()
	"""

	return StringToEnum('Intersect')[0]

def NodalEnum():
	"""
	NODALENUM - Enum of Nodal

	   Usage:
	      macro=NodalEnum()
	"""

	return StringToEnum('Nodal')[0]

def OldGradientEnum():
	"""
	OLDGRADIENTENUM - Enum of OldGradient

	   Usage:
	      macro=OldGradientEnum()
	"""

	return StringToEnum('OldGradient')[0]

def OutputFilePointerEnum():
	"""
	OUTPUTFILEPOINTERENUM - Enum of OutputFilePointer

	   Usage:
	      macro=OutputFilePointerEnum()
	"""

	return StringToEnum('OutputFilePointer')[0]

def OutputFileNameEnum():
	"""
	OUTPUTFILENAMEENUM - Enum of OutputFileName

	   Usage:
	      macro=OutputFileNameEnum()
	"""

	return StringToEnum('OutputFileName')[0]

def LockFileNameEnum():
	"""
	LOCKFILENAMEENUM - Enum of LockFileName

	   Usage:
	      macro=LockFileNameEnum()
	"""

	return StringToEnum('LockFileName')[0]

def PetscOptionsAnalysesEnum():
	"""
	PETSCOPTIONSANALYSESENUM - Enum of PetscOptionsAnalyses

	   Usage:
	      macro=PetscOptionsAnalysesEnum()
	"""

	return StringToEnum('PetscOptionsAnalyses')[0]

def PetscOptionsStringsEnum():
	"""
	PETSCOPTIONSSTRINGSENUM - Enum of PetscOptionsStrings

	   Usage:
	      macro=PetscOptionsStringsEnum()
	"""

	return StringToEnum('PetscOptionsStrings')[0]

def QmuErrNameEnum():
	"""
	QMUERRNAMEENUM - Enum of QmuErrName

	   Usage:
	      macro=QmuErrNameEnum()
	"""

	return StringToEnum('QmuErrName')[0]

def QmuInNameEnum():
	"""
	QMUINNAMEENUM - Enum of QmuInName

	   Usage:
	      macro=QmuInNameEnum()
	"""

	return StringToEnum('QmuInName')[0]

def QmuOutNameEnum():
	"""
	QMUOUTNAMEENUM - Enum of QmuOutName

	   Usage:
	      macro=QmuOutNameEnum()
	"""

	return StringToEnum('QmuOutName')[0]

def RegularEnum():
	"""
	REGULARENUM - Enum of Regular

	   Usage:
	      macro=RegularEnum()
	"""

	return StringToEnum('Regular')[0]

def ScaledEnum():
	"""
	SCALEDENUM - Enum of Scaled

	   Usage:
	      macro=ScaledEnum()
	"""

	return StringToEnum('Scaled')[0]

def SeparateEnum():
	"""
	SEPARATEENUM - Enum of Separate

	   Usage:
	      macro=SeparateEnum()
	"""

	return StringToEnum('Separate')[0]

def SsetEnum():
	"""
	SSETENUM - Enum of Sset

	   Usage:
	      macro=SsetEnum()
	"""

	return StringToEnum('Sset')[0]

def VerboseEnum():
	"""
	VERBOSEENUM - Enum of Verbose

	   Usage:
	      macro=VerboseEnum()
	"""

	return StringToEnum('Verbose')[0]

def TriangleInterpEnum():
	"""
	TRIANGLEINTERPENUM - Enum of TriangleInterp

	   Usage:
	      macro=TriangleInterpEnum()
	"""

	return StringToEnum('TriangleInterp')[0]

def BilinearInterpEnum():
	"""
	BILINEARINTERPENUM - Enum of BilinearInterp

	   Usage:
	      macro=BilinearInterpEnum()
	"""

	return StringToEnum('BilinearInterp')[0]

def NearestInterpEnum():
	"""
	NEARESTINTERPENUM - Enum of NearestInterp

	   Usage:
	      macro=NearestInterpEnum()
	"""

	return StringToEnum('NearestInterp')[0]

def XYEnum():
	"""
	XYENUM - Enum of XY

	   Usage:
	      macro=XYEnum()
	"""

	return StringToEnum('XY')[0]

def XYZPEnum():
	"""
	XYZPENUM - Enum of XYZP

	   Usage:
	      macro=XYZPEnum()
	"""

	return StringToEnum('XYZP')[0]

def OptionEnum():
	"""
	OPTIONENUM - Enum of Option

	   Usage:
	      macro=OptionEnum()
	"""

	return StringToEnum('Option')[0]

def GenericOptionEnum():
	"""
	GENERICOPTIONENUM - Enum of GenericOption

	   Usage:
	      macro=GenericOptionEnum()
	"""

	return StringToEnum('GenericOption')[0]

def OptionCellEnum():
	"""
	OPTIONCELLENUM - Enum of OptionCell

	   Usage:
	      macro=OptionCellEnum()
	"""

	return StringToEnum('OptionCell')[0]

def OptionCharEnum():
	"""
	OPTIONCHARENUM - Enum of OptionChar

	   Usage:
	      macro=OptionCharEnum()
	"""

	return StringToEnum('OptionChar')[0]

def OptionStructEnum():
	"""
	OPTIONSTRUCTENUM - Enum of OptionStruct

	   Usage:
	      macro=OptionStructEnum()
	"""

	return StringToEnum('OptionStruct')[0]

def OptionDoubleEnum():
	"""
	OPTIONDOUBLEENUM - Enum of OptionDouble

	   Usage:
	      macro=OptionDoubleEnum()
	"""

	return StringToEnum('OptionDouble')[0]

def OptionLogicalEnum():
	"""
	OPTIONLOGICALENUM - Enum of OptionLogical

	   Usage:
	      macro=OptionLogicalEnum()
	"""

	return StringToEnum('OptionLogical')[0]

def PatersonEnum():
	"""
	PATERSONENUM - Enum of Paterson

	   Usage:
	      macro=PatersonEnum()
	"""

	return StringToEnum('Paterson')[0]

def ArrheniusEnum():
	"""
	ARRHENIUSENUM - Enum of Arrhenius

	   Usage:
	      macro=ArrheniusEnum()
	"""

	return StringToEnum('Arrhenius')[0]

def MaximumNumberOfEnums():
	"""
	MAXIMUMNUMBEROFENUMS - Enum of MaximumNumberOfEnums

	   Usage:
	      macro=MaximumNumberOfEnums()
	"""

	return 498

