"""

   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 AutodiffForwardEnum():
	"""
	AUTODIFFFORWARDENUM - Enum of AutodiffForward

	   Usage:
	      macro=AutodiffForwardEnum()
	"""

	return StringToEnum('AutodiffForward')

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

	   Usage:
	      macro=AutodiffIsautodiffEnum()
	"""

	return StringToEnum('AutodiffIsautodiff')

def AutodiffReverseEnum():
	"""
	AUTODIFFREVERSEENUM - Enum of AutodiffReverse

	   Usage:
	      macro=AutodiffReverseEnum()
	"""

	return StringToEnum('AutodiffReverse')

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

	   Usage:
	      macro=BalancethicknessSpcthicknessEnum()
	"""

	return StringToEnum('BalancethicknessSpcthickness')

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

	   Usage:
	      macro=BalancethicknessStabilizationEnum()
	"""

	return StringToEnum('BalancethicknessStabilization')

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

	   Usage:
	      macro=BalancethicknessThickeningRateEnum()
	"""

	return StringToEnum('BalancethicknessThickeningRate')

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

	   Usage:
	      macro=BasalforcingsGeothermalfluxEnum()
	"""

	return StringToEnum('BasalforcingsGeothermalflux')

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

	   Usage:
	      macro=BasalforcingsMeltingRateCorrectionEnum()
	"""

	return StringToEnum('BasalforcingsMeltingRateCorrection')

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

	   Usage:
	      macro=BasalforcingsMeltingRateEnum()
	"""

	return StringToEnum('BasalforcingsMeltingRate')

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

	   Usage:
	      macro=BathymetryEnum()
	"""

	return StringToEnum('Bathymetry')

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

	   Usage:
	      macro=BedEnum()
	"""

	return StringToEnum('Bed')

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

	   Usage:
	      macro=ConstantsGEnum()
	"""

	return StringToEnum('ConstantsG')

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

	   Usage:
	      macro=ConstantsReferencetemperatureEnum()
	"""

	return StringToEnum('ConstantsReferencetemperature')

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

	   Usage:
	      macro=ConstantsYtsEnum()
	"""

	return StringToEnum('ConstantsYts')

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

	   Usage:
	      macro=DiagnosticAbstolEnum()
	"""

	return StringToEnum('DiagnosticAbstol')

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

	   Usage:
	      macro=DiagnosticIcefrontEnum()
	"""

	return StringToEnum('DiagnosticIcefront')

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

	   Usage:
	      macro=DiagnosticIsnewtonEnum()
	"""

	return StringToEnum('DiagnosticIsnewton')

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

	   Usage:
	      macro=DiagnosticMaxiterEnum()
	"""

	return StringToEnum('DiagnosticMaxiter')

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

	   Usage:
	      macro=DiagnosticNumRequestedOutputsEnum()
	"""

	return StringToEnum('DiagnosticNumRequestedOutputs')

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

	   Usage:
	      macro=DiagnosticPenaltyFactorEnum()
	"""

	return StringToEnum('DiagnosticPenaltyFactor')

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

	   Usage:
	      macro=DiagnosticReferentialEnum()
	"""

	return StringToEnum('DiagnosticReferential')

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

	   Usage:
	      macro=DiagnosticReltolEnum()
	"""

	return StringToEnum('DiagnosticReltol')

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

	   Usage:
	      macro=DiagnosticRequestedOutputsEnum()
	"""

	return StringToEnum('DiagnosticRequestedOutputs')

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

	   Usage:
	      macro=DiagnosticRestolEnum()
	"""

	return StringToEnum('DiagnosticRestol')

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

	   Usage:
	      macro=DiagnosticRiftPenaltyLockEnum()
	"""

	return StringToEnum('DiagnosticRiftPenaltyLock')

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

	   Usage:
	      macro=DiagnosticRiftPenaltyThresholdEnum()
	"""

	return StringToEnum('DiagnosticRiftPenaltyThreshold')

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

	   Usage:
	      macro=DiagnosticShelfDampeningEnum()
	"""

	return StringToEnum('DiagnosticShelfDampening')

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

	   Usage:
	      macro=DiagnosticSpcvxEnum()
	"""

	return StringToEnum('DiagnosticSpcvx')

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

	   Usage:
	      macro=DiagnosticSpcvyEnum()
	"""

	return StringToEnum('DiagnosticSpcvy')

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

	   Usage:
	      macro=DiagnosticSpcvzEnum()
	"""

	return StringToEnum('DiagnosticSpcvz')

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

	   Usage:
	      macro=DiagnosticStokesreconditioningEnum()
	"""

	return StringToEnum('DiagnosticStokesreconditioning')

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

	   Usage:
	      macro=DiagnosticVertexPairingEnum()
	"""

	return StringToEnum('DiagnosticVertexPairing')

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

	   Usage:
	      macro=DiagnosticViscosityOvershootEnum()
	"""

	return StringToEnum('DiagnosticViscosityOvershoot')

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

	   Usage:
	      macro=FlowequationBordermacayealEnum()
	"""

	return StringToEnum('FlowequationBordermacayeal')

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

	   Usage:
	      macro=FlowequationBorderpattynEnum()
	"""

	return StringToEnum('FlowequationBorderpattyn')

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

	   Usage:
	      macro=FlowequationBorderstokesEnum()
	"""

	return StringToEnum('FlowequationBorderstokes')

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

	   Usage:
	      macro=FlowequationElementEquationEnum()
	"""

	return StringToEnum('FlowequationElementEquation')

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

	   Usage:
	      macro=FlowequationIshutterEnum()
	"""

	return StringToEnum('FlowequationIshutter')

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

	   Usage:
	      macro=FlowequationIsmacayealpattynEnum()
	"""

	return StringToEnum('FlowequationIsmacayealpattyn')

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

	   Usage:
	      macro=FlowequationIsstokesEnum()
	"""

	return StringToEnum('FlowequationIsstokes')

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

	   Usage:
	      macro=FlowequationVertexEquationEnum()
	"""

	return StringToEnum('FlowequationVertexEquation')

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

	   Usage:
	      macro=FrictionCoefficientEnum()
	"""

	return StringToEnum('FrictionCoefficient')

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

	   Usage:
	      macro=FrictionPEnum()
	"""

	return StringToEnum('FrictionP')

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

	   Usage:
	      macro=FrictionQEnum()
	"""

	return StringToEnum('FrictionQ')

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

	   Usage:
	      macro=GeometryHydrostaticRatioEnum()
	"""

	return StringToEnum('GeometryHydrostaticRatio')

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

	   Usage:
	      macro=HydrologyCREnum()
	"""

	return StringToEnum('HydrologyCR')

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

	   Usage:
	      macro=HydrologyKnEnum()
	"""

	return StringToEnum('HydrologyKn')

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

	   Usage:
	      macro=HydrologyNEnum()
	"""

	return StringToEnum('HydrologyN')

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

	   Usage:
	      macro=HydrologyPEnum()
	"""

	return StringToEnum('HydrologyP')

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

	   Usage:
	      macro=HydrologyQEnum()
	"""

	return StringToEnum('HydrologyQ')

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

	   Usage:
	      macro=HydrologySpcwatercolumnEnum()
	"""

	return StringToEnum('HydrologySpcwatercolumn')

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

	   Usage:
	      macro=HydrologyStabilizationEnum()
	"""

	return StringToEnum('HydrologyStabilization')

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

	   Usage:
	      macro=InversionControlParametersEnum()
	"""

	return StringToEnum('InversionControlParameters')

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

	   Usage:
	      macro=InversionCostFunctionEnum()
	"""

	return StringToEnum('InversionCostFunction')

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

	   Usage:
	      macro=InversionCostFunctionThresholdEnum()
	"""

	return StringToEnum('InversionCostFunctionThreshold')

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

	   Usage:
	      macro=InversionCostFunctionsCoefficientsEnum()
	"""

	return StringToEnum('InversionCostFunctionsCoefficients')

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

	   Usage:
	      macro=InversionCostFunctionsEnum()
	"""

	return StringToEnum('InversionCostFunctions')

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

	   Usage:
	      macro=InversionGradientOnlyEnum()
	"""

	return StringToEnum('InversionGradientOnly')

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

	   Usage:
	      macro=InversionGradientScalingEnum()
	"""

	return StringToEnum('InversionGradientScaling')

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

	   Usage:
	      macro=InversionIscontrolEnum()
	"""

	return StringToEnum('InversionIscontrol')

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

	   Usage:
	      macro=InversionTaoEnum()
	"""

	return StringToEnum('InversionTao')

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

	   Usage:
	      macro=InversionIncompleteAdjointEnum()
	"""

	return StringToEnum('InversionIncompleteAdjoint')

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

	   Usage:
	      macro=InversionMaxParametersEnum()
	"""

	return StringToEnum('InversionMaxParameters')

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

	   Usage:
	      macro=InversionMaxiterPerStepEnum()
	"""

	return StringToEnum('InversionMaxiterPerStep')

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

	   Usage:
	      macro=InversionMinParametersEnum()
	"""

	return StringToEnum('InversionMinParameters')

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

	   Usage:
	      macro=InversionNstepsEnum()
	"""

	return StringToEnum('InversionNsteps')

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

	   Usage:
	      macro=InversionNumControlParametersEnum()
	"""

	return StringToEnum('InversionNumControlParameters')

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

	   Usage:
	      macro=InversionNumCostFunctionsEnum()
	"""

	return StringToEnum('InversionNumCostFunctions')

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

	   Usage:
	      macro=InversionStepThresholdEnum()
	"""

	return StringToEnum('InversionStepThreshold')

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

	   Usage:
	      macro=InversionThicknessObsEnum()
	"""

	return StringToEnum('InversionThicknessObs')

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

	   Usage:
	      macro=InversionVelObsEnum()
	"""

	return StringToEnum('InversionVelObs')

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

	   Usage:
	      macro=InversionVxObsEnum()
	"""

	return StringToEnum('InversionVxObs')

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

	   Usage:
	      macro=InversionVyObsEnum()
	"""

	return StringToEnum('InversionVyObs')

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

	   Usage:
	      macro=InversionVzObsEnum()
	"""

	return StringToEnum('InversionVzObs')

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

	   Usage:
	      macro=MaskElementonfloatingiceEnum()
	"""

	return StringToEnum('MaskElementonfloatingice')

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

	   Usage:
	      macro=MaskElementongroundediceEnum()
	"""

	return StringToEnum('MaskElementongroundedice')

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

	   Usage:
	      macro=MaskElementonwaterEnum()
	"""

	return StringToEnum('MaskElementonwater')

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

	   Usage:
	      macro=MaskVertexonfloatingiceEnum()
	"""

	return StringToEnum('MaskVertexonfloatingice')

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

	   Usage:
	      macro=MaskVertexongroundediceEnum()
	"""

	return StringToEnum('MaskVertexongroundedice')

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

	   Usage:
	      macro=MaskVertexonwaterEnum()
	"""

	return StringToEnum('MaskVertexonwater')

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

	   Usage:
	      macro=MaterialsBetaEnum()
	"""

	return StringToEnum('MaterialsBeta')

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

	   Usage:
	      macro=MaterialsHeatcapacityEnum()
	"""

	return StringToEnum('MaterialsHeatcapacity')

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

	   Usage:
	      macro=MaterialsLatentheatEnum()
	"""

	return StringToEnum('MaterialsLatentheat')

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

	   Usage:
	      macro=MaterialsMeltingpointEnum()
	"""

	return StringToEnum('MaterialsMeltingpoint')

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

	   Usage:
	      macro=MaterialsMixedLayerCapacityEnum()
	"""

	return StringToEnum('MaterialsMixedLayerCapacity')

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

	   Usage:
	      macro=MaterialsRheologyBEnum()
	"""

	return StringToEnum('MaterialsRheologyB')

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

	   Usage:
	      macro=MaterialsRheologyBbarEnum()
	"""

	return StringToEnum('MaterialsRheologyBbar')

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

	   Usage:
	      macro=MaterialsRheologyLawEnum()
	"""

	return StringToEnum('MaterialsRheologyLaw')

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

	   Usage:
	      macro=MaterialsRheologyNEnum()
	"""

	return StringToEnum('MaterialsRheologyN')

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

	   Usage:
	      macro=MaterialsRheologyZEnum()
	"""

	return StringToEnum('MaterialsRheologyZ')

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

	   Usage:
	      macro=MaterialsRheologyZbarEnum()
	"""

	return StringToEnum('MaterialsRheologyZbar')

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

	   Usage:
	      macro=MaterialsRhoIceEnum()
	"""

	return StringToEnum('MaterialsRhoIce')

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

	   Usage:
	      macro=MaterialsRhoWaterEnum()
	"""

	return StringToEnum('MaterialsRhoWater')

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

	   Usage:
	      macro=MaterialsRhoFreshwaterEnum()
	"""

	return StringToEnum('MaterialsRhoFreshwater')

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

	   Usage:
	      macro=MaterialsMuWaterEnum()
	"""

	return StringToEnum('MaterialsMuWater')

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

	   Usage:
	      macro=MaterialsThermalExchangeVelocityEnum()
	"""

	return StringToEnum('MaterialsThermalExchangeVelocity')

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

	   Usage:
	      macro=MaterialsThermalconductivityEnum()
	"""

	return StringToEnum('MaterialsThermalconductivity')

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

	   Usage:
	      macro=MeshAverageVertexConnectivityEnum()
	"""

	return StringToEnum('MeshAverageVertexConnectivity')

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

	   Usage:
	      macro=MeshDimensionEnum()
	"""

	return StringToEnum('MeshDimension')

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

	   Usage:
	      macro=MeshEdgesEnum()
	"""

	return StringToEnum('MeshEdges')

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

	   Usage:
	      macro=MeshElementconnectivityEnum()
	"""

	return StringToEnum('MeshElementconnectivity')

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

	   Usage:
	      macro=MeshElementonbedEnum()
	"""

	return StringToEnum('MeshElementonbed')

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

	   Usage:
	      macro=MeshElementonsurfaceEnum()
	"""

	return StringToEnum('MeshElementonsurface')

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

	   Usage:
	      macro=MeshElements2dEnum()
	"""

	return StringToEnum('MeshElements2d')

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

	   Usage:
	      macro=MeshElementsEnum()
	"""

	return StringToEnum('MeshElements')

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

	   Usage:
	      macro=MeshLowerelementsEnum()
	"""

	return StringToEnum('MeshLowerelements')

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

	   Usage:
	      macro=MeshNumberofedgesEnum()
	"""

	return StringToEnum('MeshNumberofedges')

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

	   Usage:
	      macro=MeshNumberofelements2dEnum()
	"""

	return StringToEnum('MeshNumberofelements2d')

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

	   Usage:
	      macro=MeshNumberofelementsEnum()
	"""

	return StringToEnum('MeshNumberofelements')

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

	   Usage:
	      macro=MeshNumberoflayersEnum()
	"""

	return StringToEnum('MeshNumberoflayers')

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

	   Usage:
	      macro=MeshNumberofvertices2dEnum()
	"""

	return StringToEnum('MeshNumberofvertices2d')

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

	   Usage:
	      macro=MeshNumberofverticesEnum()
	"""

	return StringToEnum('MeshNumberofvertices')

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

	   Usage:
	      macro=MeshUpperelementsEnum()
	"""

	return StringToEnum('MeshUpperelements')

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

	   Usage:
	      macro=MeshVertexonbedEnum()
	"""

	return StringToEnum('MeshVertexonbed')

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

	   Usage:
	      macro=MeshVertexonsurfaceEnum()
	"""

	return StringToEnum('MeshVertexonsurface')

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

	   Usage:
	      macro=MeshXEnum()
	"""

	return StringToEnum('MeshX')

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

	   Usage:
	      macro=MeshYEnum()
	"""

	return StringToEnum('MeshY')

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

	   Usage:
	      macro=MeshZEnum()
	"""

	return StringToEnum('MeshZ')

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

	   Usage:
	      macro=MiscellaneousNameEnum()
	"""

	return StringToEnum('MiscellaneousName')

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

	   Usage:
	      macro=PrognosticHydrostaticAdjustmentEnum()
	"""

	return StringToEnum('PrognosticHydrostaticAdjustment')

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

	   Usage:
	      macro=PrognosticMinThicknessEnum()
	"""

	return StringToEnum('PrognosticMinThickness')

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

	   Usage:
	      macro=PrognosticPenaltyFactorEnum()
	"""

	return StringToEnum('PrognosticPenaltyFactor')

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

	   Usage:
	      macro=PrognosticSpcthicknessEnum()
	"""

	return StringToEnum('PrognosticSpcthickness')

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

	   Usage:
	      macro=PrognosticStabilizationEnum()
	"""

	return StringToEnum('PrognosticStabilization')

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

	   Usage:
	      macro=PrognosticVertexPairingEnum()
	"""

	return StringToEnum('PrognosticVertexPairing')

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

	   Usage:
	      macro=QmuIsdakotaEnum()
	"""

	return StringToEnum('QmuIsdakota')

def QmuMassFluxSegmentsEnum():
	"""
	QMUMASSFLUXSEGMENTSENUM - Enum of QmuMassFluxSegments

	   Usage:
	      macro=QmuMassFluxSegmentsEnum()
	"""

	return StringToEnum('QmuMassFluxSegments')

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

	   Usage:
	      macro=QmuNumberofpartitionsEnum()
	"""

	return StringToEnum('QmuNumberofpartitions')

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

	   Usage:
	      macro=QmuNumberofresponsesEnum()
	"""

	return StringToEnum('QmuNumberofresponses')

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

	   Usage:
	      macro=QmuPartitionEnum()
	"""

	return StringToEnum('QmuPartition')

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

	   Usage:
	      macro=QmuResponsedescriptorsEnum()
	"""

	return StringToEnum('QmuResponsedescriptors')

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

	   Usage:
	      macro=QmuVariabledescriptorsEnum()
	"""

	return StringToEnum('QmuVariabledescriptors')

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

	   Usage:
	      macro=RiftsNumriftsEnum()
	"""

	return StringToEnum('RiftsNumrifts')

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

	   Usage:
	      macro=RiftsRiftstructEnum()
	"""

	return StringToEnum('RiftsRiftstruct')

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

	   Usage:
	      macro=SettingsIoGatherEnum()
	"""

	return StringToEnum('SettingsIoGather')

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

	   Usage:
	      macro=SettingsLowmemEnum()
	"""

	return StringToEnum('SettingsLowmem')

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

	   Usage:
	      macro=SettingsOutputFrequencyEnum()
	"""

	return StringToEnum('SettingsOutputFrequency')

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

	   Usage:
	      macro=SettingsResultsAsPatchesEnum()
	"""

	return StringToEnum('SettingsResultsAsPatches')

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

	   Usage:
	      macro=SettingsWaitonlockEnum()
	"""

	return StringToEnum('SettingsWaitonlock')

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

	   Usage:
	      macro=SurfaceforcingsDelta18oEnum()
	"""

	return StringToEnum('SurfaceforcingsDelta18o')

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

	   Usage:
	      macro=SurfaceforcingsDelta18oSurfaceEnum()
	"""

	return StringToEnum('SurfaceforcingsDelta18oSurface')

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

	   Usage:
	      macro=SurfaceforcingsIsdelta18oEnum()
	"""

	return StringToEnum('SurfaceforcingsIsdelta18o')

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

	   Usage:
	      macro=SurfaceforcingsPrecipitationsPresentdayEnum()
	"""

	return StringToEnum('SurfaceforcingsPrecipitationsPresentday')

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

	   Usage:
	      macro=SurfaceforcingsTemperaturesPresentdayEnum()
	"""

	return StringToEnum('SurfaceforcingsTemperaturesPresentday')

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

	   Usage:
	      macro=SurfaceforcingsTemperaturesLgmEnum()
	"""

	return StringToEnum('SurfaceforcingsTemperaturesLgm')

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

	   Usage:
	      macro=DebugProfilingEnum()
	"""

	return StringToEnum('DebugProfiling')

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

	   Usage:
	      macro=ProfilingCurrentMemEnum()
	"""

	return StringToEnum('ProfilingCurrentMem')

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

	   Usage:
	      macro=ProfilingCurrentFlopsEnum()
	"""

	return StringToEnum('ProfilingCurrentFlops')

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

	   Usage:
	      macro=ProfilingSolutionTimeEnum()
	"""

	return StringToEnum('ProfilingSolutionTime')

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

	   Usage:
	      macro=MaxIterationConvergenceFlagEnum()
	"""

	return StringToEnum('MaxIterationConvergenceFlag')

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

	   Usage:
	      macro=SteadystateMaxiterEnum()
	"""

	return StringToEnum('SteadystateMaxiter')

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

	   Usage:
	      macro=SteadystateNumRequestedOutputsEnum()
	"""

	return StringToEnum('SteadystateNumRequestedOutputs')

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

	   Usage:
	      macro=SteadystateReltolEnum()
	"""

	return StringToEnum('SteadystateReltol')

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

	   Usage:
	      macro=SteadystateRequestedOutputsEnum()
	"""

	return StringToEnum('SteadystateRequestedOutputs')

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

	   Usage:
	      macro=SurfaceEnum()
	"""

	return StringToEnum('Surface')

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

	   Usage:
	      macro=SurfaceforcingsPrecipitationEnum()
	"""

	return StringToEnum('SurfaceforcingsPrecipitation')

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

	   Usage:
	      macro=SurfaceforcingsMassBalanceEnum()
	"""

	return StringToEnum('SurfaceforcingsMassBalance')

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

	   Usage:
	      macro=SurfaceforcingsIspddEnum()
	"""

	return StringToEnum('SurfaceforcingsIspdd')

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

	   Usage:
	      macro=SurfaceforcingsIssmbgradientsEnum()
	"""

	return StringToEnum('SurfaceforcingsIssmbgradients')

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

	   Usage:
	      macro=SurfaceforcingsMonthlytemperaturesEnum()
	"""

	return StringToEnum('SurfaceforcingsMonthlytemperatures')

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

	   Usage:
	      macro=SurfaceforcingsHcEnum()
	"""

	return StringToEnum('SurfaceforcingsHc')

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

	   Usage:
	      macro=SurfaceforcingsSmbPosMaxEnum()
	"""

	return StringToEnum('SurfaceforcingsSmbPosMax')

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

	   Usage:
	      macro=SurfaceforcingsSmbPosMinEnum()
	"""

	return StringToEnum('SurfaceforcingsSmbPosMin')

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

	   Usage:
	      macro=SurfaceforcingsAPosEnum()
	"""

	return StringToEnum('SurfaceforcingsAPos')

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

	   Usage:
	      macro=SurfaceforcingsBPosEnum()
	"""

	return StringToEnum('SurfaceforcingsBPos')

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

	   Usage:
	      macro=SurfaceforcingsANegEnum()
	"""

	return StringToEnum('SurfaceforcingsANeg')

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

	   Usage:
	      macro=SurfaceforcingsBNegEnum()
	"""

	return StringToEnum('SurfaceforcingsBNeg')

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

	   Usage:
	      macro=ThermalMaxiterEnum()
	"""

	return StringToEnum('ThermalMaxiter')

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

	   Usage:
	      macro=ThermalPenaltyFactorEnum()
	"""

	return StringToEnum('ThermalPenaltyFactor')

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

	   Usage:
	      macro=ThermalPenaltyLockEnum()
	"""

	return StringToEnum('ThermalPenaltyLock')

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

	   Usage:
	      macro=ThermalPenaltyThresholdEnum()
	"""

	return StringToEnum('ThermalPenaltyThreshold')

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

	   Usage:
	      macro=ThermalSpctemperatureEnum()
	"""

	return StringToEnum('ThermalSpctemperature')

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

	   Usage:
	      macro=ThermalStabilizationEnum()
	"""

	return StringToEnum('ThermalStabilization')

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

	   Usage:
	      macro=ThermalIsenthalpyEnum()
	"""

	return StringToEnum('ThermalIsenthalpy')

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

	   Usage:
	      macro=ThicknessEnum()
	"""

	return StringToEnum('Thickness')

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

	   Usage:
	      macro=TimesteppingStartTimeEnum()
	"""

	return StringToEnum('TimesteppingStartTime')

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

	   Usage:
	      macro=TimesteppingFinalTimeEnum()
	"""

	return StringToEnum('TimesteppingFinalTime')

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

	   Usage:
	      macro=TimesteppingCflCoefficientEnum()
	"""

	return StringToEnum('TimesteppingCflCoefficient')

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

	   Usage:
	      macro=TimesteppingTimeAdaptEnum()
	"""

	return StringToEnum('TimesteppingTimeAdapt')

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

	   Usage:
	      macro=TimesteppingTimeStepEnum()
	"""

	return StringToEnum('TimesteppingTimeStep')

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

	   Usage:
	      macro=TransientIsdiagnosticEnum()
	"""

	return StringToEnum('TransientIsdiagnostic')

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

	   Usage:
	      macro=TransientIsgroundinglineEnum()
	"""

	return StringToEnum('TransientIsgroundingline')

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

	   Usage:
	      macro=TransientIsprognosticEnum()
	"""

	return StringToEnum('TransientIsprognostic')

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

	   Usage:
	      macro=TransientIsthermalEnum()
	"""

	return StringToEnum('TransientIsthermal')

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

	   Usage:
	      macro=TransientNumRequestedOutputsEnum()
	"""

	return StringToEnum('TransientNumRequestedOutputs')

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

	   Usage:
	      macro=TransientRequestedOutputsEnum()
	"""

	return StringToEnum('TransientRequestedOutputs')

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

	   Usage:
	      macro=SolutionTypeEnum()
	"""

	return StringToEnum('SolutionType')

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

	   Usage:
	      macro=AnalysisTypeEnum()
	"""

	return StringToEnum('AnalysisType')

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

	   Usage:
	      macro=ConfigurationTypeEnum()
	"""

	return StringToEnum('ConfigurationType')

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

	   Usage:
	      macro=AdjointBalancethicknessAnalysisEnum()
	"""

	return StringToEnum('AdjointBalancethicknessAnalysis')

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

	   Usage:
	      macro=AdjointHorizAnalysisEnum()
	"""

	return StringToEnum('AdjointHorizAnalysis')

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

	   Usage:
	      macro=AdjointSolutionEnum()
	"""

	return StringToEnum('AdjointSolution')

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

	   Usage:
	      macro=AnalysisCounterEnum()
	"""

	return StringToEnum('AnalysisCounter')

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

	   Usage:
	      macro=BalancethicknessAnalysisEnum()
	"""

	return StringToEnum('BalancethicknessAnalysis')

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

	   Usage:
	      macro=BalancethicknessSolutionEnum()
	"""

	return StringToEnum('BalancethicknessSolution')

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

	   Usage:
	      macro=BedSlopeAnalysisEnum()
	"""

	return StringToEnum('BedSlopeAnalysis')

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

	   Usage:
	      macro=BedSlopeSolutionEnum()
	"""

	return StringToEnum('BedSlopeSolution')

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

	   Usage:
	      macro=BedSlopeXAnalysisEnum()
	"""

	return StringToEnum('BedSlopeXAnalysis')

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

	   Usage:
	      macro=BedSlopeYAnalysisEnum()
	"""

	return StringToEnum('BedSlopeYAnalysis')

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

	   Usage:
	      macro=DiagnosticHorizAnalysisEnum()
	"""

	return StringToEnum('DiagnosticHorizAnalysis')

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

	   Usage:
	      macro=DiagnosticHutterAnalysisEnum()
	"""

	return StringToEnum('DiagnosticHutterAnalysis')

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

	   Usage:
	      macro=DiagnosticSolutionEnum()
	"""

	return StringToEnum('DiagnosticSolution')

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

	   Usage:
	      macro=DiagnosticVertAnalysisEnum()
	"""

	return StringToEnum('DiagnosticVertAnalysis')

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

	   Usage:
	      macro=EnthalpyAnalysisEnum()
	"""

	return StringToEnum('EnthalpyAnalysis')

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

	   Usage:
	      macro=EnthalpySolutionEnum()
	"""

	return StringToEnum('EnthalpySolution')

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

	   Usage:
	      macro=FlaimAnalysisEnum()
	"""

	return StringToEnum('FlaimAnalysis')

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

	   Usage:
	      macro=FlaimSolutionEnum()
	"""

	return StringToEnum('FlaimSolution')

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

	   Usage:
	      macro=HydrologyAnalysisEnum()
	"""

	return StringToEnum('HydrologyAnalysis')

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

	   Usage:
	      macro=HydrologySolutionEnum()
	"""

	return StringToEnum('HydrologySolution')

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

	   Usage:
	      macro=MeltingAnalysisEnum()
	"""

	return StringToEnum('MeltingAnalysis')

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

	   Usage:
	      macro=NoneAnalysisEnum()
	"""

	return StringToEnum('NoneAnalysis')

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

	   Usage:
	      macro=PrognosticAnalysisEnum()
	"""

	return StringToEnum('PrognosticAnalysis')

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

	   Usage:
	      macro=PrognosticSolutionEnum()
	"""

	return StringToEnum('PrognosticSolution')

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

	   Usage:
	      macro=SteadystateSolutionEnum()
	"""

	return StringToEnum('SteadystateSolution')

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

	   Usage:
	      macro=SurfaceSlopeAnalysisEnum()
	"""

	return StringToEnum('SurfaceSlopeAnalysis')

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

	   Usage:
	      macro=SurfaceSlopeSolutionEnum()
	"""

	return StringToEnum('SurfaceSlopeSolution')

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

	   Usage:
	      macro=SurfaceSlopeXAnalysisEnum()
	"""

	return StringToEnum('SurfaceSlopeXAnalysis')

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

	   Usage:
	      macro=SurfaceSlopeYAnalysisEnum()
	"""

	return StringToEnum('SurfaceSlopeYAnalysis')

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

	   Usage:
	      macro=ThermalAnalysisEnum()
	"""

	return StringToEnum('ThermalAnalysis')

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

	   Usage:
	      macro=ThermalSolutionEnum()
	"""

	return StringToEnum('ThermalSolution')

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

	   Usage:
	      macro=TransientSolutionEnum()
	"""

	return StringToEnum('TransientSolution')

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

	   Usage:
	      macro=ApproximationEnum()
	"""

	return StringToEnum('Approximation')

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

	   Usage:
	      macro=HutterApproximationEnum()
	"""

	return StringToEnum('HutterApproximation')

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

	   Usage:
	      macro=MacAyealApproximationEnum()
	"""

	return StringToEnum('MacAyealApproximation')

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

	   Usage:
	      macro=MacAyealPattynApproximationEnum()
	"""

	return StringToEnum('MacAyealPattynApproximation')

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

	   Usage:
	      macro=MacAyealStokesApproximationEnum()
	"""

	return StringToEnum('MacAyealStokesApproximation')

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

	   Usage:
	      macro=NoneApproximationEnum()
	"""

	return StringToEnum('NoneApproximation')

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

	   Usage:
	      macro=PattynApproximationEnum()
	"""

	return StringToEnum('PattynApproximation')

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

	   Usage:
	      macro=PattynStokesApproximationEnum()
	"""

	return StringToEnum('PattynStokesApproximation')

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

	   Usage:
	      macro=StokesApproximationEnum()
	"""

	return StringToEnum('StokesApproximation')

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

	   Usage:
	      macro=ConstraintsEnum()
	"""

	return StringToEnum('Constraints')

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

	   Usage:
	      macro=LoadsEnum()
	"""

	return StringToEnum('Loads')

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

	   Usage:
	      macro=MaterialsEnum()
	"""

	return StringToEnum('Materials')

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

	   Usage:
	      macro=NodesEnum()
	"""

	return StringToEnum('Nodes')

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

	   Usage:
	      macro=ParametersEnum()
	"""

	return StringToEnum('Parameters')

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

	   Usage:
	      macro=VerticesEnum()
	"""

	return StringToEnum('Vertices')

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

	   Usage:
	      macro=ResultsEnum()
	"""

	return StringToEnum('Results')

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

	   Usage:
	      macro=BoolInputEnum()
	"""

	return StringToEnum('BoolInput')

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

	   Usage:
	      macro=BoolParamEnum()
	"""

	return StringToEnum('BoolParam')

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

	   Usage:
	      macro=ContourEnum()
	"""

	return StringToEnum('Contour')

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

	   Usage:
	      macro=ControlInputEnum()
	"""

	return StringToEnum('ControlInput')

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

	   Usage:
	      macro=DatasetInputEnum()
	"""

	return StringToEnum('DatasetInput')

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

	   Usage:
	      macro=DofIndexingEnum()
	"""

	return StringToEnum('DofIndexing')

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

	   Usage:
	      macro=DoubleInputEnum()
	"""

	return StringToEnum('DoubleInput')

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

	   Usage:
	      macro=DoubleMatArrayParamEnum()
	"""

	return StringToEnum('DoubleMatArrayParam')

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

	   Usage:
	      macro=DoubleMatParamEnum()
	"""

	return StringToEnum('DoubleMatParam')

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

	   Usage:
	      macro=DoubleParamEnum()
	"""

	return StringToEnum('DoubleParam')

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

	   Usage:
	      macro=DoubleVecParamEnum()
	"""

	return StringToEnum('DoubleVecParam')

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

	   Usage:
	      macro=ElementEnum()
	"""

	return StringToEnum('Element')

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

	   Usage:
	      macro=ElementResultEnum()
	"""

	return StringToEnum('ElementResult')

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

	   Usage:
	      macro=ExternalResultEnum()
	"""

	return StringToEnum('ExternalResult')

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

	   Usage:
	      macro=FileParamEnum()
	"""

	return StringToEnum('FileParam')

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

	   Usage:
	      macro=HookEnum()
	"""

	return StringToEnum('Hook')

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

	   Usage:
	      macro=IcefrontEnum()
	"""

	return StringToEnum('Icefront')

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

	   Usage:
	      macro=InputEnum()
	"""

	return StringToEnum('Input')

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

	   Usage:
	      macro=IntInputEnum()
	"""

	return StringToEnum('IntInput')

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

	   Usage:
	      macro=IntParamEnum()
	"""

	return StringToEnum('IntParam')

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

	   Usage:
	      macro=IntVecParamEnum()
	"""

	return StringToEnum('IntVecParam')

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

	   Usage:
	      macro=TransientParamEnum()
	"""

	return StringToEnum('TransientParam')

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

	   Usage:
	      macro=MacAyeal2dIceFrontEnum()
	"""

	return StringToEnum('MacAyeal2dIceFront')

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

	   Usage:
	      macro=MacAyeal3dIceFrontEnum()
	"""

	return StringToEnum('MacAyeal3dIceFront')

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

	   Usage:
	      macro=MaticeEnum()
	"""

	return StringToEnum('Matice')

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

	   Usage:
	      macro=MatparEnum()
	"""

	return StringToEnum('Matpar')

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

	   Usage:
	      macro=NodeEnum()
	"""

	return StringToEnum('Node')

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

	   Usage:
	      macro=NumericalfluxEnum()
	"""

	return StringToEnum('Numericalflux')

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

	   Usage:
	      macro=ParamEnum()
	"""

	return StringToEnum('Param')

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

	   Usage:
	      macro=PattynIceFrontEnum()
	"""

	return StringToEnum('PattynIceFront')

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

	   Usage:
	      macro=PengridEnum()
	"""

	return StringToEnum('Pengrid')

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

	   Usage:
	      macro=PenpairEnum()
	"""

	return StringToEnum('Penpair')

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

	   Usage:
	      macro=PentaEnum()
	"""

	return StringToEnum('Penta')

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

	   Usage:
	      macro=PentaP1InputEnum()
	"""

	return StringToEnum('PentaP1Input')

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

	   Usage:
	      macro=MatrixParamEnum()
	"""

	return StringToEnum('MatrixParam')

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

	   Usage:
	      macro=VectorParamEnum()
	"""

	return StringToEnum('VectorParam')

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

	   Usage:
	      macro=RiftfrontEnum()
	"""

	return StringToEnum('Riftfront')

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

	   Usage:
	      macro=SegmentEnum()
	"""

	return StringToEnum('Segment')

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

	   Usage:
	      macro=SegmentRiftfrontEnum()
	"""

	return StringToEnum('SegmentRiftfront')

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

	   Usage:
	      macro=SpcDynamicEnum()
	"""

	return StringToEnum('SpcDynamic')

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

	   Usage:
	      macro=SpcStaticEnum()
	"""

	return StringToEnum('SpcStatic')

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

	   Usage:
	      macro=SpcTransientEnum()
	"""

	return StringToEnum('SpcTransient')

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

	   Usage:
	      macro=StokesIceFrontEnum()
	"""

	return StringToEnum('StokesIceFront')

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

	   Usage:
	      macro=StringArrayParamEnum()
	"""

	return StringToEnum('StringArrayParam')

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

	   Usage:
	      macro=StringParamEnum()
	"""

	return StringToEnum('StringParam')

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

	   Usage:
	      macro=TriaEnum()
	"""

	return StringToEnum('Tria')

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

	   Usage:
	      macro=TriaP1InputEnum()
	"""

	return StringToEnum('TriaP1Input')

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

	   Usage:
	      macro=VertexEnum()
	"""

	return StringToEnum('Vertex')

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

	   Usage:
	      macro=AirEnum()
	"""

	return StringToEnum('Air')

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

	   Usage:
	      macro=IceEnum()
	"""

	return StringToEnum('Ice')

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

	   Usage:
	      macro=MelangeEnum()
	"""

	return StringToEnum('Melange')

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

	   Usage:
	      macro=WaterEnum()
	"""

	return StringToEnum('Water')

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

	   Usage:
	      macro=ClosedEnum()
	"""

	return StringToEnum('Closed')

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

	   Usage:
	      macro=FreeEnum()
	"""

	return StringToEnum('Free')

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

	   Usage:
	      macro=OpenEnum()
	"""

	return StringToEnum('Open')

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

	   Usage:
	      macro=AdjointpEnum()
	"""

	return StringToEnum('Adjointp')

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

	   Usage:
	      macro=AdjointxEnum()
	"""

	return StringToEnum('Adjointx')

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

	   Usage:
	      macro=AdjointyEnum()
	"""

	return StringToEnum('Adjointy')

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

	   Usage:
	      macro=AdjointzEnum()
	"""

	return StringToEnum('Adjointz')

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

	   Usage:
	      macro=BedSlopeXEnum()
	"""

	return StringToEnum('BedSlopeX')

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

	   Usage:
	      macro=BedSlopeYEnum()
	"""

	return StringToEnum('BedSlopeY')

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

	   Usage:
	      macro=BoundaryEnum()
	"""

	return StringToEnum('Boundary')

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

	   Usage:
	      macro=ConstantEnum()
	"""

	return StringToEnum('Constant')

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

	   Usage:
	      macro=ConvergedEnum()
	"""

	return StringToEnum('Converged')

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

	   Usage:
	      macro=ExtToIuEnum()
	"""

	return StringToEnum('ExtToIu')

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

	   Usage:
	      macro=FillEnum()
	"""

	return StringToEnum('Fill')

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

	   Usage:
	      macro=FractionIncrementEnum()
	"""

	return StringToEnum('FractionIncrement')

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

	   Usage:
	      macro=FrictionEnum()
	"""

	return StringToEnum('Friction')

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

	   Usage:
	      macro=GroundinglineMeltingRateEnum()
	"""

	return StringToEnum('GroundinglineMeltingRate')

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

	   Usage:
	      macro=InternalEnum()
	"""

	return StringToEnum('Internal')

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

	   Usage:
	      macro=IuToExtEnum()
	"""

	return StringToEnum('IuToExt')

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

	   Usage:
	      macro=MassFluxEnum()
	"""

	return StringToEnum('MassFlux')

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

	   Usage:
	      macro=MaxPenetrationEnum()
	"""

	return StringToEnum('MaxPenetration')

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

	   Usage:
	      macro=MeltingOffsetEnum()
	"""

	return StringToEnum('MeltingOffset')

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

	   Usage:
	      macro=MisfitEnum()
	"""

	return StringToEnum('Misfit')

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

	   Usage:
	      macro=NumberNodeToElementConnectivityEnum()
	"""

	return StringToEnum('NumberNodeToElementConnectivity')

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

	   Usage:
	      macro=PressureEnum()
	"""

	return StringToEnum('Pressure')

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

	   Usage:
	      macro=PressurePicardEnum()
	"""

	return StringToEnum('PressurePicard')

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

	   Usage:
	      macro=QmuPressureEnum()
	"""

	return StringToEnum('QmuPressure')

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

	   Usage:
	      macro=QmuVxEnum()
	"""

	return StringToEnum('QmuVx')

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

	   Usage:
	      macro=QmuVyEnum()
	"""

	return StringToEnum('QmuVy')

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

	   Usage:
	      macro=QmuVzEnum()
	"""

	return StringToEnum('QmuVz')

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

	   Usage:
	      macro=QmuThicknessEnum()
	"""

	return StringToEnum('QmuThickness')

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

	   Usage:
	      macro=QmuBedEnum()
	"""

	return StringToEnum('QmuBed')

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

	   Usage:
	      macro=QmuSurfaceEnum()
	"""

	return StringToEnum('QmuSurface')

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

	   Usage:
	      macro=QmuMeltingEnum()
	"""

	return StringToEnum('QmuMelting')

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

	   Usage:
	      macro=ResetPenaltiesEnum()
	"""

	return StringToEnum('ResetPenalties')

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

	   Usage:
	      macro=SegmentOnIceShelfEnum()
	"""

	return StringToEnum('SegmentOnIceShelf')

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

	   Usage:
	      macro=SurfaceAbsVelMisfitEnum()
	"""

	return StringToEnum('SurfaceAbsVelMisfit')

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

	   Usage:
	      macro=SurfaceAreaEnum()
	"""

	return StringToEnum('SurfaceArea')

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

	   Usage:
	      macro=SurfaceAverageVelMisfitEnum()
	"""

	return StringToEnum('SurfaceAverageVelMisfit')

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

	   Usage:
	      macro=SurfaceLogVelMisfitEnum()
	"""

	return StringToEnum('SurfaceLogVelMisfit')

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

	   Usage:
	      macro=SurfaceLogVxVyMisfitEnum()
	"""

	return StringToEnum('SurfaceLogVxVyMisfit')

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

	   Usage:
	      macro=SurfaceRelVelMisfitEnum()
	"""

	return StringToEnum('SurfaceRelVelMisfit')

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

	   Usage:
	      macro=SurfaceSlopeXEnum()
	"""

	return StringToEnum('SurfaceSlopeX')

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

	   Usage:
	      macro=SurfaceSlopeYEnum()
	"""

	return StringToEnum('SurfaceSlopeY')

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

	   Usage:
	      macro=TemperatureEnum()
	"""

	return StringToEnum('Temperature')

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

	   Usage:
	      macro=TemperatureOldEnum()
	"""

	return StringToEnum('TemperatureOld')

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

	   Usage:
	      macro=TemperaturePicardEnum()
	"""

	return StringToEnum('TemperaturePicard')

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

	   Usage:
	      macro=ThicknessAbsMisfitEnum()
	"""

	return StringToEnum('ThicknessAbsMisfit')

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

	   Usage:
	      macro=TypeEnum()
	"""

	return StringToEnum('Type')

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

	   Usage:
	      macro=VelEnum()
	"""

	return StringToEnum('Vel')

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

	   Usage:
	      macro=VelocityEnum()
	"""

	return StringToEnum('Velocity')

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

	   Usage:
	      macro=VxAverageEnum()
	"""

	return StringToEnum('VxAverage')

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

	   Usage:
	      macro=VxEnum()
	"""

	return StringToEnum('Vx')

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

	   Usage:
	      macro=VxPicardEnum()
	"""

	return StringToEnum('VxPicard')

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

	   Usage:
	      macro=VyAverageEnum()
	"""

	return StringToEnum('VyAverage')

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

	   Usage:
	      macro=VyEnum()
	"""

	return StringToEnum('Vy')

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

	   Usage:
	      macro=VyPicardEnum()
	"""

	return StringToEnum('VyPicard')

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

	   Usage:
	      macro=VzEnum()
	"""

	return StringToEnum('Vz')

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

	   Usage:
	      macro=VzMacAyealEnum()
	"""

	return StringToEnum('VzMacAyeal')

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

	   Usage:
	      macro=VzPattynEnum()
	"""

	return StringToEnum('VzPattyn')

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

	   Usage:
	      macro=VzPicardEnum()
	"""

	return StringToEnum('VzPicard')

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

	   Usage:
	      macro=VzStokesEnum()
	"""

	return StringToEnum('VzStokes')

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

	   Usage:
	      macro=VxMeshEnum()
	"""

	return StringToEnum('VxMesh')

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

	   Usage:
	      macro=VyMeshEnum()
	"""

	return StringToEnum('VyMesh')

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

	   Usage:
	      macro=VzMeshEnum()
	"""

	return StringToEnum('VzMesh')

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

	   Usage:
	      macro=EnthalpyEnum()
	"""

	return StringToEnum('Enthalpy')

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

	   Usage:
	      macro=EnthalpyPicardEnum()
	"""

	return StringToEnum('EnthalpyPicard')

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

	   Usage:
	      macro=ThicknessAbsGradientEnum()
	"""

	return StringToEnum('ThicknessAbsGradient')

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

	   Usage:
	      macro=StepResponsesEnum()
	"""

	return StringToEnum('StepResponses')

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

	   Usage:
	      macro=IntMatParamEnum()
	"""

	return StringToEnum('IntMatParam')

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

	   Usage:
	      macro=RheologyBbarAbsGradientEnum()
	"""

	return StringToEnum('RheologyBbarAbsGradient')

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

	   Usage:
	      macro=DragCoefficientAbsGradientEnum()
	"""

	return StringToEnum('DragCoefficientAbsGradient')

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

	   Usage:
	      macro=TransientInputEnum()
	"""

	return StringToEnum('TransientInput')

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

	   Usage:
	      macro=OutputfilenameEnum()
	"""

	return StringToEnum('Outputfilename')

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

	   Usage:
	      macro=WaterfractionEnum()
	"""

	return StringToEnum('Waterfraction')

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

	   Usage:
	      macro=WatercolumnEnum()
	"""

	return StringToEnum('Watercolumn')

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

	   Usage:
	      macro=BasalFrictionEnum()
	"""

	return StringToEnum('BasalFriction')

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

	   Usage:
	      macro=ViscousHeatingEnum()
	"""

	return StringToEnum('ViscousHeating')

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

	   Usage:
	      macro=QmuTemperatureEnum()
	"""

	return StringToEnum('QmuTemperature')

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

	   Usage:
	      macro=HydrologyWaterVxEnum()
	"""

	return StringToEnum('HydrologyWaterVx')

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

	   Usage:
	      macro=HydrologyWaterVyEnum()
	"""

	return StringToEnum('HydrologyWaterVy')

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

	   Usage:
	      macro=StressTensorEnum()
	"""

	return StringToEnum('StressTensor')

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

	   Usage:
	      macro=StressTensorxxEnum()
	"""

	return StringToEnum('StressTensorxx')

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

	   Usage:
	      macro=StressTensorxyEnum()
	"""

	return StringToEnum('StressTensorxy')

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

	   Usage:
	      macro=StressTensorxzEnum()
	"""

	return StringToEnum('StressTensorxz')

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

	   Usage:
	      macro=StressTensoryyEnum()
	"""

	return StringToEnum('StressTensoryy')

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

	   Usage:
	      macro=StressTensoryzEnum()
	"""

	return StringToEnum('StressTensoryz')

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

	   Usage:
	      macro=StressTensorzzEnum()
	"""

	return StringToEnum('StressTensorzz')

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

	   Usage:
	      macro=IceVolumeEnum()
	"""

	return StringToEnum('IceVolume')

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

	   Usage:
	      macro=TotalSmbEnum()
	"""

	return StringToEnum('TotalSmb')

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

	   Usage:
	      macro=P0Enum()
	"""

	return StringToEnum('P0')

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

	   Usage:
	      macro=P1Enum()
	"""

	return StringToEnum('P1')

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

	   Usage:
	      macro=P1DGEnum()
	"""

	return StringToEnum('P1DG')

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

	   Usage:
	      macro=SaveResultsEnum()
	"""

	return StringToEnum('SaveResults')

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

	   Usage:
	      macro=BoolElementResultEnum()
	"""

	return StringToEnum('BoolElementResult')

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

	   Usage:
	      macro=BoolExternalResultEnum()
	"""

	return StringToEnum('BoolExternalResult')

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

	   Usage:
	      macro=DoubleElementResultEnum()
	"""

	return StringToEnum('DoubleElementResult')

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

	   Usage:
	      macro=DoubleExternalResultEnum()
	"""

	return StringToEnum('DoubleExternalResult')

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

	   Usage:
	      macro=DoubleMatExternalResultEnum()
	"""

	return StringToEnum('DoubleMatExternalResult')

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

	   Usage:
	      macro=DoubleVecExternalResultEnum()
	"""

	return StringToEnum('DoubleVecExternalResult')

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

	   Usage:
	      macro=IntExternalResultEnum()
	"""

	return StringToEnum('IntExternalResult')

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

	   Usage:
	      macro=JEnum()
	"""

	return StringToEnum('J')

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

	   Usage:
	      macro=PatchEnum()
	"""

	return StringToEnum('Patch')

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

	   Usage:
	      macro=PatchNodesEnum()
	"""

	return StringToEnum('PatchNodes')

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

	   Usage:
	      macro=PatchVerticesEnum()
	"""

	return StringToEnum('PatchVertices')

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

	   Usage:
	      macro=PentaP1ElementResultEnum()
	"""

	return StringToEnum('PentaP1ElementResult')

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

	   Usage:
	      macro=PetscVecExternalResultEnum()
	"""

	return StringToEnum('PetscVecExternalResult')

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

	   Usage:
	      macro=StringExternalResultEnum()
	"""

	return StringToEnum('StringExternalResult')

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

	   Usage:
	      macro=StepEnum()
	"""

	return StringToEnum('Step')

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

	   Usage:
	      macro=TimeEnum()
	"""

	return StringToEnum('Time')

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

	   Usage:
	      macro=TriaP1ElementResultEnum()
	"""

	return StringToEnum('TriaP1ElementResult')

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

	   Usage:
	      macro=WaterColumnOldEnum()
	"""

	return StringToEnum('WaterColumnOld')

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

	   Usage:
	      macro=MinVelEnum()
	"""

	return StringToEnum('MinVel')

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

	   Usage:
	      macro=MaxVelEnum()
	"""

	return StringToEnum('MaxVel')

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

	   Usage:
	      macro=MinVxEnum()
	"""

	return StringToEnum('MinVx')

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

	   Usage:
	      macro=MaxVxEnum()
	"""

	return StringToEnum('MaxVx')

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

	   Usage:
	      macro=MaxAbsVxEnum()
	"""

	return StringToEnum('MaxAbsVx')

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

	   Usage:
	      macro=MinVyEnum()
	"""

	return StringToEnum('MinVy')

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

	   Usage:
	      macro=MaxVyEnum()
	"""

	return StringToEnum('MaxVy')

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

	   Usage:
	      macro=MaxAbsVyEnum()
	"""

	return StringToEnum('MaxAbsVy')

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

	   Usage:
	      macro=MinVzEnum()
	"""

	return StringToEnum('MinVz')

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

	   Usage:
	      macro=MaxVzEnum()
	"""

	return StringToEnum('MaxVz')

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

	   Usage:
	      macro=MaxAbsVzEnum()
	"""

	return StringToEnum('MaxAbsVz')

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

	   Usage:
	      macro=RelativeEnum()
	"""

	return StringToEnum('Relative')

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

	   Usage:
	      macro=AbsoluteEnum()
	"""

	return StringToEnum('Absolute')

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

	   Usage:
	      macro=IncrementalEnum()
	"""

	return StringToEnum('Incremental')

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

	   Usage:
	      macro=AgressiveMigrationEnum()
	"""

	return StringToEnum('AgressiveMigration')

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

	   Usage:
	      macro=NoneEnum()
	"""

	return StringToEnum('None')

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

	   Usage:
	      macro=SoftMigrationEnum()
	"""

	return StringToEnum('SoftMigration')

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

	   Usage:
	      macro=StokesSolverEnum()
	"""

	return StringToEnum('StokesSolver')

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

	   Usage:
	      macro=AdjointEnum()
	"""

	return StringToEnum('Adjoint')

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

	   Usage:
	      macro=ColinearEnum()
	"""

	return StringToEnum('Colinear')

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

	   Usage:
	      macro=ControlSteadyEnum()
	"""

	return StringToEnum('ControlSteady')

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

	   Usage:
	      macro=FsetEnum()
	"""

	return StringToEnum('Fset')

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

	   Usage:
	      macro=Gradient1Enum()
	"""

	return StringToEnum('Gradient1')

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

	   Usage:
	      macro=Gradient2Enum()
	"""

	return StringToEnum('Gradient2')

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

	   Usage:
	      macro=Gradient3Enum()
	"""

	return StringToEnum('Gradient3')

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

	   Usage:
	      macro=GradientEnum()
	"""

	return StringToEnum('Gradient')

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

	   Usage:
	      macro=GroundinglineMigrationEnum()
	"""

	return StringToEnum('GroundinglineMigration')

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

	   Usage:
	      macro=GsetEnum()
	"""

	return StringToEnum('Gset')

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

	   Usage:
	      macro=IndexEnum()
	"""

	return StringToEnum('Index')

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

	   Usage:
	      macro=IndexedEnum()
	"""

	return StringToEnum('Indexed')

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

	   Usage:
	      macro=IntersectEnum()
	"""

	return StringToEnum('Intersect')

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

	   Usage:
	      macro=NodalEnum()
	"""

	return StringToEnum('Nodal')

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

	   Usage:
	      macro=OldGradientEnum()
	"""

	return StringToEnum('OldGradient')

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

	   Usage:
	      macro=OutputFilePointerEnum()
	"""

	return StringToEnum('OutputFilePointer')

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

	   Usage:
	      macro=PetscOptionsAnalysesEnum()
	"""

	return StringToEnum('PetscOptionsAnalyses')

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

	   Usage:
	      macro=PetscOptionsStringsEnum()
	"""

	return StringToEnum('PetscOptionsStrings')

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

	   Usage:
	      macro=QmuErrNameEnum()
	"""

	return StringToEnum('QmuErrName')

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

	   Usage:
	      macro=QmuInNameEnum()
	"""

	return StringToEnum('QmuInName')

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

	   Usage:
	      macro=QmuOutNameEnum()
	"""

	return StringToEnum('QmuOutName')

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

	   Usage:
	      macro=RegularEnum()
	"""

	return StringToEnum('Regular')

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

	   Usage:
	      macro=ScaledEnum()
	"""

	return StringToEnum('Scaled')

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

	   Usage:
	      macro=SeparateEnum()
	"""

	return StringToEnum('Separate')

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

	   Usage:
	      macro=SsetEnum()
	"""

	return StringToEnum('Sset')

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

	   Usage:
	      macro=VerboseEnum()
	"""

	return StringToEnum('Verbose')

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

	   Usage:
	      macro=TriangleInterpEnum()
	"""

	return StringToEnum('TriangleInterp')

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

	   Usage:
	      macro=BilinearInterpEnum()
	"""

	return StringToEnum('BilinearInterp')

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

	   Usage:
	      macro=NearestInterpEnum()
	"""

	return StringToEnum('NearestInterp')

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

	   Usage:
	      macro=XYEnum()
	"""

	return StringToEnum('XY')

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

	   Usage:
	      macro=XYZPEnum()
	"""

	return StringToEnum('XYZP')

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

	   Usage:
	      macro=OptionEnum()
	"""

	return StringToEnum('Option')

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

	   Usage:
	      macro=OptionCellEnum()
	"""

	return StringToEnum('OptionCell')

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

	   Usage:
	      macro=OptionCharEnum()
	"""

	return StringToEnum('OptionChar')

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

	   Usage:
	      macro=OptionStructEnum()
	"""

	return StringToEnum('OptionStruct')

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

	   Usage:
	      macro=OptionDoubleEnum()
	"""

	return StringToEnum('OptionDouble')

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

	   Usage:
	      macro=OptionLogicalEnum()
	"""

	return StringToEnum('OptionLogical')

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

	   Usage:
	      macro=PatersonEnum()
	"""

	return StringToEnum('Paterson')

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

	   Usage:
	      macro=ArrheniusEnum()
	"""

	return StringToEnum('Arrhenius')

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

	   Usage:
	      macro=MaximumNumberOfEnums()
	"""

	return 458

