Index: /issm/trunk-jpl/src/m/enum/EnumDefinitions.py =================================================================== --- /issm/trunk-jpl/src/m/enum/EnumDefinitions.py (revision 12685) +++ /issm/trunk-jpl/src/m/enum/EnumDefinitions.py (revision 12685) @@ -0,0 +1,4498 @@ +""" + + 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 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 DebugPetscProfilingEnum(): + """ + DEBUGPETSCPROFILINGENUM - Enum of DebugPetscProfiling + + Usage: + macro=DebugPetscProfilingEnum() + """ + + return StringToEnum('DebugPetscProfiling') + +def PetscProfilingCurrentMemEnum(): + """ + PETSCPROFILINGCURRENTMEMENUM - Enum of PetscProfilingCurrentMem + + Usage: + macro=PetscProfilingCurrentMemEnum() + """ + + return StringToEnum('PetscProfilingCurrentMem') + +def PetscProfilingCurrentFlopsEnum(): + """ + PETSCPROFILINGCURRENTFLOPSENUM - Enum of PetscProfilingCurrentFlops + + Usage: + macro=PetscProfilingCurrentFlopsEnum() + """ + + return StringToEnum('PetscProfilingCurrentFlops') + +def PetscProfilingSolutionTimeEnum(): + """ + PETSCPROFILINGSOLUTIONTIMEENUM - Enum of PetscProfilingSolutionTime + + Usage: + macro=PetscProfilingSolutionTimeEnum() + """ + + return StringToEnum('PetscProfilingSolutionTime') + +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 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 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 448 + Index: /issm/trunk-jpl/src/m/enum/SurfaceforcingsANegEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/SurfaceforcingsANegEnum.m (revision 12685) +++ /issm/trunk-jpl/src/m/enum/SurfaceforcingsANegEnum.m (revision 12685) @@ -0,0 +1,11 @@ +function macro=SurfaceforcingsANegEnum() +%SURFACEFORCINGSANEGENUM - Enum of SurfaceforcingsANeg +% +% 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 +% +% Usage: +% macro=SurfaceforcingsANegEnum() + +macro=StringToEnum('SurfaceforcingsANeg'); Index: /issm/trunk-jpl/src/m/enum/SurfaceforcingsAPosEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/SurfaceforcingsAPosEnum.m (revision 12685) +++ /issm/trunk-jpl/src/m/enum/SurfaceforcingsAPosEnum.m (revision 12685) @@ -0,0 +1,11 @@ +function macro=SurfaceforcingsAPosEnum() +%SURFACEFORCINGSAPOSENUM - Enum of SurfaceforcingsAPos +% +% 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 +% +% Usage: +% macro=SurfaceforcingsAPosEnum() + +macro=StringToEnum('SurfaceforcingsAPos'); Index: /issm/trunk-jpl/src/m/enum/SurfaceforcingsBNegEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/SurfaceforcingsBNegEnum.m (revision 12685) +++ /issm/trunk-jpl/src/m/enum/SurfaceforcingsBNegEnum.m (revision 12685) @@ -0,0 +1,11 @@ +function macro=SurfaceforcingsBNegEnum() +%SURFACEFORCINGSBNEGENUM - Enum of SurfaceforcingsBNeg +% +% 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 +% +% Usage: +% macro=SurfaceforcingsBNegEnum() + +macro=StringToEnum('SurfaceforcingsBNeg'); Index: /issm/trunk-jpl/src/m/enum/SurfaceforcingsBPosEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/SurfaceforcingsBPosEnum.m (revision 12685) +++ /issm/trunk-jpl/src/m/enum/SurfaceforcingsBPosEnum.m (revision 12685) @@ -0,0 +1,11 @@ +function macro=SurfaceforcingsBPosEnum() +%SURFACEFORCINGSBPOSENUM - Enum of SurfaceforcingsBPos +% +% 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 +% +% Usage: +% macro=SurfaceforcingsBPosEnum() + +macro=StringToEnum('SurfaceforcingsBPos'); Index: /issm/trunk-jpl/src/m/enum/SurfaceforcingsHcEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/SurfaceforcingsHcEnum.m (revision 12685) +++ /issm/trunk-jpl/src/m/enum/SurfaceforcingsHcEnum.m (revision 12685) @@ -0,0 +1,11 @@ +function macro=SurfaceforcingsHcEnum() +%SURFACEFORCINGSHCENUM - Enum of SurfaceforcingsHc +% +% 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 +% +% Usage: +% macro=SurfaceforcingsHcEnum() + +macro=StringToEnum('SurfaceforcingsHc'); Index: /issm/trunk-jpl/src/m/enum/SurfaceforcingsIssmbgradientsEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/SurfaceforcingsIssmbgradientsEnum.m (revision 12685) +++ /issm/trunk-jpl/src/m/enum/SurfaceforcingsIssmbgradientsEnum.m (revision 12685) @@ -0,0 +1,11 @@ +function macro=SurfaceforcingsIssmbgradientsEnum() +%SURFACEFORCINGSISSMBGRADIENTSENUM - Enum of SurfaceforcingsIssmbgradients +% +% 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 +% +% Usage: +% macro=SurfaceforcingsIssmbgradientsEnum() + +macro=StringToEnum('SurfaceforcingsIssmbgradients'); Index: /issm/trunk-jpl/src/m/enum/SurfaceforcingsSmbPosMaxEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/SurfaceforcingsSmbPosMaxEnum.m (revision 12685) +++ /issm/trunk-jpl/src/m/enum/SurfaceforcingsSmbPosMaxEnum.m (revision 12685) @@ -0,0 +1,11 @@ +function macro=SurfaceforcingsSmbPosMaxEnum() +%SURFACEFORCINGSSMBPOSMAXENUM - Enum of SurfaceforcingsSmbPosMax +% +% 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 +% +% Usage: +% macro=SurfaceforcingsSmbPosMaxEnum() + +macro=StringToEnum('SurfaceforcingsSmbPosMax'); Index: /issm/trunk-jpl/src/m/enum/SurfaceforcingsSmbPosMinEnum.m =================================================================== --- /issm/trunk-jpl/src/m/enum/SurfaceforcingsSmbPosMinEnum.m (revision 12685) +++ /issm/trunk-jpl/src/m/enum/SurfaceforcingsSmbPosMinEnum.m (revision 12685) @@ -0,0 +1,11 @@ +function macro=SurfaceforcingsSmbPosMinEnum() +%SURFACEFORCINGSSMBPOSMINENUM - Enum of SurfaceforcingsSmbPosMin +% +% 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 +% +% Usage: +% macro=SurfaceforcingsSmbPosMinEnum() + +macro=StringToEnum('SurfaceforcingsSmbPosMin');