Index: /issm/trunk-jpl/src/c/EnumDefinitions/EnumDefinitions.h =================================================================== --- /issm/trunk-jpl/src/c/EnumDefinitions/EnumDefinitions.h (revision 14957) +++ /issm/trunk-jpl/src/c/EnumDefinitions/EnumDefinitions.h (revision 14958) @@ -7,6 +7,6 @@ #define _ENUM_DEFINITIONS_ -#include "../modules/EnumToStringx/EnumToStringx.h" -#include "../modules/StringToEnumx/StringToEnumx.h" +#include "../shared/Enum/EnumToStringx.h" +#include "../shared/Enum/StringToEnumx.h" enum definitions{ Index: /issm/trunk-jpl/src/c/Makefile.am =================================================================== --- /issm/trunk-jpl/src/c/Makefile.am (revision 14957) +++ /issm/trunk-jpl/src/c/Makefile.am (revision 14958) @@ -191,4 +191,8 @@ ./shared/io/Comm/IssmComm.h\ ./shared/io/Comm/IssmComm.cpp\ + ./shared/Enum/EnumToStringx.cpp\ + ./shared/Enum/EnumToStringx.h\ + ./shared/Enum/StringToEnumx.cpp\ + ./shared/Enum/StringToEnumx.h\ ./shared/Numerics/numerics.h\ ./shared/Numerics/types.h\ @@ -305,8 +309,4 @@ ./modules/Reduceloadx/Reduceloadx.h\ ./modules/Reduceloadx/Reduceloadx.cpp\ - ./modules/EnumToStringx/EnumToStringx.cpp\ - ./modules/EnumToStringx/EnumToStringx.h\ - ./modules/StringToEnumx/StringToEnumx.cpp\ - ./modules/StringToEnumx/StringToEnumx.h\ ./modules/ConstraintsStatex/ConstraintsStatex.cpp\ ./modules/ConstraintsStatex/ConstraintsStatex.h\ Index: /issm/trunk-jpl/src/c/modules/modules.h =================================================================== --- /issm/trunk-jpl/src/c/modules/modules.h (revision 14957) +++ /issm/trunk-jpl/src/c/modules/modules.h (revision 14958) @@ -26,6 +26,4 @@ #include "./ElementConnectivityx/ElementConnectivityx.h" #include "./EdgeDetectionx/EdgeDetectionx.h" -#include "./EnumToStringx/EnumToStringx.h" -#include "./StringToEnumx/StringToEnumx.h" #include "./GetSolutionFromInputsx/GetSolutionFromInputsx.h" #include "./GetVectorFromInputsx/GetVectorFromInputsx.h" Index: /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp (revision 14958) +++ /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp (revision 14958) @@ -0,0 +1,580 @@ +/* +* \file EnumToStringx.cpp: +* \brief: output string associated with enum +* +* WARNING: DO NOT MODIFY THIS FILE +* this file has been automatically generated by Synchronize.sh +* Please read README for more information +*/ + +#include +#include "./EnumToStringx.h" +#include "../Exceptions/exceptions.h" +#include "../MemOps/MemOps.h" +#include "../../EnumDefinitions/EnumDefinitions.h" + +const char* EnumToStringx(int en){ + + switch(en){ + + case AutodiffIsautodiffEnum : return "AutodiffIsautodiff"; + case AutodiffNumDependentsEnum : return "AutodiffNumDependents"; + case AutodiffNumDependentObjectsEnum : return "AutodiffNumDependentObjects"; + case AutodiffDependentObjectNamesEnum : return "AutodiffDependentObjectNames"; + case AutodiffDependentObjectTypesEnum : return "AutodiffDependentObjectTypes"; + case AutodiffDependentObjectIndicesEnum : return "AutodiffDependentObjectIndices"; + case AutodiffDependentObjectsEnum : return "AutodiffDependentObjects"; + case AutodiffNumIndependentsEnum : return "AutodiffNumIndependents"; + case AutodiffNumIndependentObjectsEnum : return "AutodiffNumIndependentObjects"; + case AutodiffIndependentObjectNamesEnum : return "AutodiffIndependentObjectNames"; + case AutodiffIndependentObjectTypesEnum : return "AutodiffIndependentObjectTypes"; + case AutodiffIndependentObjectsEnum : return "AutodiffIndependentObjects"; + case AutodiffJacobianEnum : return "AutodiffJacobian"; + case AutodiffXpEnum : return "AutodiffXp"; + case AutodiffDriverEnum : return "AutodiffDriver"; + case AutodiffFosForwardIndexEnum : return "AutodiffFosForwardIndex"; + case AutodiffFovForwardIndicesEnum : return "AutodiffFovForwardIndices"; + case AutodiffFosReverseIndexEnum : return "AutodiffFosReverseIndex"; + case AutodiffMassFluxSegmentsPresentEnum : return "AutodiffMassFluxSegmentsPresent"; + case AutodiffKeepEnum : return "AutodiffKeep"; + case BalancethicknessSpcthicknessEnum : return "BalancethicknessSpcthickness"; + case BalancethicknessStabilizationEnum : return "BalancethicknessStabilization"; + case BalancethicknessThickeningRateEnum : return "BalancethicknessThickeningRate"; + case BasalforcingsGeothermalfluxEnum : return "BasalforcingsGeothermalflux"; + case BasalforcingsMeltingRateCorrectionEnum : return "BasalforcingsMeltingRateCorrection"; + case BasalforcingsMeltingRateEnum : return "BasalforcingsMeltingRate"; + case BathymetryEnum : return "Bathymetry"; + case BedEnum : return "Bed"; + case ConstantsGEnum : return "ConstantsG"; + case ConstantsReferencetemperatureEnum : return "ConstantsReferencetemperature"; + case ConstantsYtsEnum : return "ConstantsYts"; + case DependentObjectEnum : return "DependentObject"; + case DiagnosticAbstolEnum : return "DiagnosticAbstol"; + case DiagnosticIcefrontEnum : return "DiagnosticIcefront"; + case DiagnosticIsnewtonEnum : return "DiagnosticIsnewton"; + case DiagnosticMaxiterEnum : return "DiagnosticMaxiter"; + case DiagnosticNumRequestedOutputsEnum : return "DiagnosticNumRequestedOutputs"; + case DiagnosticPenaltyFactorEnum : return "DiagnosticPenaltyFactor"; + case DiagnosticReferentialEnum : return "DiagnosticReferential"; + case DiagnosticReltolEnum : return "DiagnosticReltol"; + case DiagnosticRequestedOutputsEnum : return "DiagnosticRequestedOutputs"; + case DiagnosticRestolEnum : return "DiagnosticRestol"; + case DiagnosticRiftPenaltyLockEnum : return "DiagnosticRiftPenaltyLock"; + case DiagnosticRiftPenaltyThresholdEnum : return "DiagnosticRiftPenaltyThreshold"; + case DiagnosticShelfDampeningEnum : return "DiagnosticShelfDampening"; + case DiagnosticSpcvxEnum : return "DiagnosticSpcvx"; + case DiagnosticSpcvyEnum : return "DiagnosticSpcvy"; + case DiagnosticSpcvzEnum : return "DiagnosticSpcvz"; + case DiagnosticStokesreconditioningEnum : return "DiagnosticStokesreconditioning"; + case DiagnosticVertexPairingEnum : return "DiagnosticVertexPairing"; + case DiagnosticViscosityOvershootEnum : return "DiagnosticViscosityOvershoot"; + case LoadingforceXEnum : return "LoadingforceX"; + case LoadingforceYEnum : return "LoadingforceY"; + case LoadingforceZEnum : return "LoadingforceZ"; + case FlowequationBordermacayealEnum : return "FlowequationBordermacayeal"; + case FlowequationBorderpattynEnum : return "FlowequationBorderpattyn"; + case FlowequationBorderstokesEnum : return "FlowequationBorderstokes"; + case FlowequationElementEquationEnum : return "FlowequationElementEquation"; + case FlowequationIshutterEnum : return "FlowequationIshutter"; + case FlowequationIsl1l2Enum : return "FlowequationIsl1l2"; + case FlowequationIsmacayealpattynEnum : return "FlowequationIsmacayealpattyn"; + case FlowequationIsstokesEnum : return "FlowequationIsstokes"; + case FlowequationVertexEquationEnum : return "FlowequationVertexEquation"; + case FrictionCoefficientEnum : return "FrictionCoefficient"; + case FrictionPEnum : return "FrictionP"; + case FrictionQEnum : return "FrictionQ"; + case GeometryHydrostaticRatioEnum : return "GeometryHydrostaticRatio"; + case HydrologyModelEnum : return "HydrologyModel"; + case HydrologyshreveEnum : return "Hydrologyshreve"; + case HydrologyshreveCREnum : return "HydrologyshreveCR"; + case HydrologyshreveKnEnum : return "HydrologyshreveKn"; + case HydrologyshreveNEnum : return "HydrologyshreveN"; + case HydrologyshrevePEnum : return "HydrologyshreveP"; + case HydrologyshreveQEnum : return "HydrologyshreveQ"; + case HydrologyshreveSpcwatercolumnEnum : return "HydrologyshreveSpcwatercolumn"; + case HydrologyshreveStabilizationEnum : return "HydrologyshreveStabilization"; + case HydrologydcEnum : return "Hydrologydc"; + case SedimentHeadEnum : return "SedimentHead"; + case SedimentHeadResidualEnum : return "SedimentHeadResidual"; + case EplHeadEnum : return "EplHead"; + case HydrologydcSpcsedimentHeadEnum : return "HydrologydcSpcsedimentHead"; + case HydrologydcSedimentCompressibilityEnum : return "HydrologydcSedimentCompressibility"; + case HydrologydcSedimentPorosityEnum : return "HydrologydcSedimentPorosity"; + case HydrologydcSedimentThicknessEnum : return "HydrologydcSedimentThickness"; + case HydrologydcSedimentTransmitivityEnum : return "HydrologydcSedimentTransmitivity"; + case HydrologydcWaterCompressibilityEnum : return "HydrologydcWaterCompressibility"; + case HydrologydcSpceplHeadEnum : return "HydrologydcSpceplHead"; + case HydrologydcEplCompressibilityEnum : return "HydrologydcEplCompressibility"; + case HydrologydcEplPorosityEnum : return "HydrologydcEplPorosity"; + case HydrologydcEplThicknessEnum : return "HydrologydcEplThickness"; + case HydrologydcEplTransmitivityEnum : return "HydrologydcEplTransmitivity"; + case HydrologydcIsefficientlayerEnum : return "HydrologydcIsefficientlayer"; + case HydrologydcSedimentlimitFlagEnum : return "HydrologydcSedimentlimitFlag"; + case HydrologydcSedimentlimitEnum : return "HydrologydcSedimentlimit"; + case HydrologydcPenaltyFactorEnum : return "HydrologydcPenaltyFactor"; + case HydrologyLayerEnum : return "HydrologyLayer"; + case HydrologySedimentEnum : return "HydrologySediment"; + case HydrologyEfficientEnum : return "HydrologyEfficient"; + case HydrologySedimentKmaxEnum : return "HydrologySedimentKmax"; + case IndependentObjectEnum : return "IndependentObject"; + case InversionControlParametersEnum : return "InversionControlParameters"; + case InversionCostFunctionThresholdEnum : return "InversionCostFunctionThreshold"; + case InversionCostFunctionsCoefficientsEnum : return "InversionCostFunctionsCoefficients"; + case InversionCostFunctionsEnum : return "InversionCostFunctions"; + case InversionGradientOnlyEnum : return "InversionGradientOnly"; + case InversionGradientScalingEnum : return "InversionGradientScaling"; + case InversionIscontrolEnum : return "InversionIscontrol"; + case InversionTaoEnum : return "InversionTao"; + case InversionIncompleteAdjointEnum : return "InversionIncompleteAdjoint"; + case InversionMaxParametersEnum : return "InversionMaxParameters"; + case InversionMaxiterPerStepEnum : return "InversionMaxiterPerStep"; + case InversionMinParametersEnum : return "InversionMinParameters"; + case InversionNstepsEnum : return "InversionNsteps"; + case InversionNumControlParametersEnum : return "InversionNumControlParameters"; + case InversionNumCostFunctionsEnum : return "InversionNumCostFunctions"; + case InversionStepThresholdEnum : return "InversionStepThreshold"; + case InversionThicknessObsEnum : return "InversionThicknessObs"; + case InversionVelObsEnum : return "InversionVelObs"; + case InversionVxObsEnum : return "InversionVxObs"; + case InversionVyObsEnum : return "InversionVyObs"; + case InversionVzObsEnum : return "InversionVzObs"; + case MaskElementonfloatingiceEnum : return "MaskElementonfloatingice"; + case MaskElementongroundediceEnum : return "MaskElementongroundedice"; + case MaskElementonwaterEnum : return "MaskElementonwater"; + case MaskVertexonfloatingiceEnum : return "MaskVertexonfloatingice"; + case MaskVertexongroundediceEnum : return "MaskVertexongroundedice"; + case MaskVertexonwaterEnum : return "MaskVertexonwater"; + case MaterialsBetaEnum : return "MaterialsBeta"; + case MaterialsHeatcapacityEnum : return "MaterialsHeatcapacity"; + case MaterialsLatentheatEnum : return "MaterialsLatentheat"; + case MaterialsMeltingpointEnum : return "MaterialsMeltingpoint"; + case MaterialsMixedLayerCapacityEnum : return "MaterialsMixedLayerCapacity"; + case MaterialsRheologyBEnum : return "MaterialsRheologyB"; + case MaterialsRheologyBbarEnum : return "MaterialsRheologyBbar"; + case MaterialsRheologyLawEnum : return "MaterialsRheologyLaw"; + case MaterialsRheologyNEnum : return "MaterialsRheologyN"; + case MaterialsRheologyZEnum : return "MaterialsRheologyZ"; + case MaterialsRheologyZbarEnum : return "MaterialsRheologyZbar"; + case MaterialsRhoIceEnum : return "MaterialsRhoIce"; + case MaterialsRhoWaterEnum : return "MaterialsRhoWater"; + case MaterialsRhoFreshwaterEnum : return "MaterialsRhoFreshwater"; + case MaterialsMuWaterEnum : return "MaterialsMuWater"; + case MaterialsThermalExchangeVelocityEnum : return "MaterialsThermalExchangeVelocity"; + case MaterialsThermalconductivityEnum : return "MaterialsThermalconductivity"; + case MaterialsLithosphereShearModulusEnum : return "MaterialsLithosphereShearModulus"; + case MaterialsLithosphereDensityEnum : return "MaterialsLithosphereDensity"; + case MaterialsMantleShearModulusEnum : return "MaterialsMantleShearModulus"; + case MaterialsMantleDensityEnum : return "MaterialsMantleDensity"; + case MeshAverageVertexConnectivityEnum : return "MeshAverageVertexConnectivity"; + case MeshDimensionEnum : return "MeshDimension"; + case MeshEdgesEnum : return "MeshEdges"; + case MeshElementconnectivityEnum : return "MeshElementconnectivity"; + case MeshElementonbedEnum : return "MeshElementonbed"; + case MeshElementonsurfaceEnum : return "MeshElementonsurface"; + case MeshElements2dEnum : return "MeshElements2d"; + case MeshElementsEnum : return "MeshElements"; + case MeshLowerelementsEnum : return "MeshLowerelements"; + case MeshNumberofedgesEnum : return "MeshNumberofedges"; + case MeshNumberofelements2dEnum : return "MeshNumberofelements2d"; + case MeshNumberofelementsEnum : return "MeshNumberofelements"; + case MeshNumberoflayersEnum : return "MeshNumberoflayers"; + case MeshNumberofvertices2dEnum : return "MeshNumberofvertices2d"; + case MeshNumberofverticesEnum : return "MeshNumberofvertices"; + case MeshUpperelementsEnum : return "MeshUpperelements"; + case MeshVertexonbedEnum : return "MeshVertexonbed"; + case MeshVertexonsurfaceEnum : return "MeshVertexonsurface"; + case MeshXEnum : return "MeshX"; + case MeshYEnum : return "MeshY"; + case MeshZEnum : return "MeshZ"; + case MiscellaneousNameEnum : return "MiscellaneousName"; + case PrognosticHydrostaticAdjustmentEnum : return "PrognosticHydrostaticAdjustment"; + case PrognosticMinThicknessEnum : return "PrognosticMinThickness"; + case PrognosticPenaltyFactorEnum : return "PrognosticPenaltyFactor"; + case PrognosticSpcthicknessEnum : return "PrognosticSpcthickness"; + case PrognosticStabilizationEnum : return "PrognosticStabilization"; + case PrognosticVertexPairingEnum : return "PrognosticVertexPairing"; + case PrognosticNumRequestedOutputsEnum : return "PrognosticNumRequestedOutputs"; + case PrognosticRequestedOutputsEnum : return "PrognosticRequestedOutputs"; + case QmuIsdakotaEnum : return "QmuIsdakota"; + case MassFluxSegmentsEnum : return "MassFluxSegments"; + case MassFluxSegmentsPresentEnum : return "MassFluxSegmentsPresent"; + case QmuMassFluxSegmentsPresentEnum : return "QmuMassFluxSegmentsPresent"; + case QmuNumberofpartitionsEnum : return "QmuNumberofpartitions"; + case QmuNumberofresponsesEnum : return "QmuNumberofresponses"; + case QmuPartitionEnum : return "QmuPartition"; + case QmuResponsedescriptorsEnum : return "QmuResponsedescriptors"; + case QmuVariabledescriptorsEnum : return "QmuVariabledescriptors"; + case RiftsNumriftsEnum : return "RiftsNumrifts"; + case RiftsRiftstructEnum : return "RiftsRiftstruct"; + case SettingsIoGatherEnum : return "SettingsIoGather"; + case SettingsLowmemEnum : return "SettingsLowmem"; + case SettingsOutputFrequencyEnum : return "SettingsOutputFrequency"; + case SettingsResultsAsPatchesEnum : return "SettingsResultsAsPatches"; + case SettingsWaitonlockEnum : return "SettingsWaitonlock"; + case SurfaceforcingsDelta18oEnum : return "SurfaceforcingsDelta18o"; + case SurfaceforcingsDelta18oSurfaceEnum : return "SurfaceforcingsDelta18oSurface"; + case SurfaceforcingsIsdelta18oEnum : return "SurfaceforcingsIsdelta18o"; + case SurfaceforcingsPrecipitationsPresentdayEnum : return "SurfaceforcingsPrecipitationsPresentday"; + case SurfaceforcingsTemperaturesPresentdayEnum : return "SurfaceforcingsTemperaturesPresentday"; + case SurfaceforcingsTemperaturesLgmEnum : return "SurfaceforcingsTemperaturesLgm"; + case DebugProfilingEnum : return "DebugProfiling"; + case ProfilingCurrentMemEnum : return "ProfilingCurrentMem"; + case ProfilingCurrentFlopsEnum : return "ProfilingCurrentFlops"; + case ProfilingSolutionTimeEnum : return "ProfilingSolutionTime"; + case MaxIterationConvergenceFlagEnum : return "MaxIterationConvergenceFlag"; + case SteadystateMaxiterEnum : return "SteadystateMaxiter"; + case SteadystateNumRequestedOutputsEnum : return "SteadystateNumRequestedOutputs"; + case SteadystateReltolEnum : return "SteadystateReltol"; + case SteadystateRequestedOutputsEnum : return "SteadystateRequestedOutputs"; + case SurfaceEnum : return "Surface"; + case SurfaceforcingsPrecipitationEnum : return "SurfaceforcingsPrecipitation"; + case SurfaceforcingsMassBalanceEnum : return "SurfaceforcingsMassBalance"; + case SurfaceforcingsIspddEnum : return "SurfaceforcingsIspdd"; + case SurfaceforcingsDesfacEnum : return "SurfaceforcingsDesfac"; + case SurfaceforcingsS0pEnum : return "SurfaceforcingsS0p"; + case SurfaceforcingsIssmbgradientsEnum : return "SurfaceforcingsIssmbgradients"; + case SurfaceforcingsMonthlytemperaturesEnum : return "SurfaceforcingsMonthlytemperatures"; + case SurfaceforcingsHrefEnum : return "SurfaceforcingsHref"; + case SurfaceforcingsSmbrefEnum : return "SurfaceforcingsSmbref"; + case SurfaceforcingsBPosEnum : return "SurfaceforcingsBPos"; + case SurfaceforcingsBNegEnum : return "SurfaceforcingsBNeg"; + case ThermalMaxiterEnum : return "ThermalMaxiter"; + case ThermalPenaltyFactorEnum : return "ThermalPenaltyFactor"; + case ThermalPenaltyLockEnum : return "ThermalPenaltyLock"; + case ThermalPenaltyThresholdEnum : return "ThermalPenaltyThreshold"; + case ThermalSpctemperatureEnum : return "ThermalSpctemperature"; + case ThermalStabilizationEnum : return "ThermalStabilization"; + case ThermalIsenthalpyEnum : return "ThermalIsenthalpy"; + case GiaMantleViscosityEnum : return "GiaMantleViscosity"; + case GiaLithosphereThicknessEnum : return "GiaLithosphereThickness"; + case ThicknessEnum : return "Thickness"; + case TimesteppingStartTimeEnum : return "TimesteppingStartTime"; + case TimesteppingFinalTimeEnum : return "TimesteppingFinalTime"; + case TimesteppingCflCoefficientEnum : return "TimesteppingCflCoefficient"; + case TimesteppingTimeAdaptEnum : return "TimesteppingTimeAdapt"; + case TimesteppingTimeStepEnum : return "TimesteppingTimeStep"; + case TransientIsdiagnosticEnum : return "TransientIsdiagnostic"; + case TransientIsgroundinglineEnum : return "TransientIsgroundingline"; + case TransientIsprognosticEnum : return "TransientIsprognostic"; + case TransientIsthermalEnum : return "TransientIsthermal"; + case TransientIsgiaEnum : return "TransientIsgia"; + case TransientNumRequestedOutputsEnum : return "TransientNumRequestedOutputs"; + case TransientRequestedOutputsEnum : return "TransientRequestedOutputs"; + case SolutionTypeEnum : return "SolutionType"; + case AnalysisTypeEnum : return "AnalysisType"; + case ConfigurationTypeEnum : return "ConfigurationType"; + case AdjointBalancethicknessAnalysisEnum : return "AdjointBalancethicknessAnalysis"; + case AdjointHorizAnalysisEnum : return "AdjointHorizAnalysis"; + case AdjointSolutionEnum : return "AdjointSolution"; + case AnalysisCounterEnum : return "AnalysisCounter"; + case NoneAnalysisEnum : return "NoneAnalysis"; + case DefaultAnalysisEnum : return "DefaultAnalysis"; + case BalancethicknessAnalysisEnum : return "BalancethicknessAnalysis"; + case BalancethicknessSolutionEnum : return "BalancethicknessSolution"; + case WeakBalancethicknessAnalysisEnum : return "WeakBalancethicknessAnalysis"; + case WeakBalancethicknessSolutionEnum : return "WeakBalancethicknessSolution"; + case BedSlopeAnalysisEnum : return "BedSlopeAnalysis"; + case BedSlopeSolutionEnum : return "BedSlopeSolution"; + case BedSlopeXAnalysisEnum : return "BedSlopeXAnalysis"; + case BedSlopeYAnalysisEnum : return "BedSlopeYAnalysis"; + case DiagnosticHorizAnalysisEnum : return "DiagnosticHorizAnalysis"; + case DiagnosticHutterAnalysisEnum : return "DiagnosticHutterAnalysis"; + case DiagnosticSolutionEnum : return "DiagnosticSolution"; + case DiagnosticVertAnalysisEnum : return "DiagnosticVertAnalysis"; + case EnthalpyAnalysisEnum : return "EnthalpyAnalysis"; + case EnthalpySolutionEnum : return "EnthalpySolution"; + case FlaimAnalysisEnum : return "FlaimAnalysis"; + case FlaimSolutionEnum : return "FlaimSolution"; + case HydrologyShreveAnalysisEnum : return "HydrologyShreveAnalysis"; + case HydrologyDCInefficientAnalysisEnum : return "HydrologyDCInefficientAnalysis"; + case HydrologyDCEfficientAnalysisEnum : return "HydrologyDCEfficientAnalysis"; + case HydrologySolutionEnum : return "HydrologySolution"; + case MeltingAnalysisEnum : return "MeltingAnalysis"; + case PrognosticAnalysisEnum : return "PrognosticAnalysis"; + case PrognosticSolutionEnum : return "PrognosticSolution"; + case SteadystateSolutionEnum : return "SteadystateSolution"; + case SurfaceSlopeAnalysisEnum : return "SurfaceSlopeAnalysis"; + case SurfaceSlopeSolutionEnum : return "SurfaceSlopeSolution"; + case SurfaceSlopeXAnalysisEnum : return "SurfaceSlopeXAnalysis"; + case SurfaceSlopeYAnalysisEnum : return "SurfaceSlopeYAnalysis"; + case ThermalAnalysisEnum : return "ThermalAnalysis"; + case ThermalSolutionEnum : return "ThermalSolution"; + case TransientSolutionEnum : return "TransientSolution"; + case GiaSolutionEnum : return "GiaSolution"; + case GiaAnalysisEnum : return "GiaAnalysis"; + case ApproximationEnum : return "Approximation"; + case NoneApproximationEnum : return "NoneApproximation"; + case HutterApproximationEnum : return "HutterApproximation"; + case MacAyealApproximationEnum : return "MacAyealApproximation"; + case MacAyealPattynApproximationEnum : return "MacAyealPattynApproximation"; + case MacAyealStokesApproximationEnum : return "MacAyealStokesApproximation"; + case L1L2ApproximationEnum : return "L1L2Approximation"; + case PattynApproximationEnum : return "PattynApproximation"; + case PattynStokesApproximationEnum : return "PattynStokesApproximation"; + case StokesApproximationEnum : return "StokesApproximation"; + case ConstraintsEnum : return "Constraints"; + case LoadsEnum : return "Loads"; + case MaterialsEnum : return "Materials"; + case NodesEnum : return "Nodes"; + case ParametersEnum : return "Parameters"; + case VerticesEnum : return "Vertices"; + case ResultsEnum : return "Results"; + case GenericParamEnum : return "GenericParam"; + case AdolcParamEnum : return "AdolcParam"; + case BoolInputEnum : return "BoolInput"; + case BoolParamEnum : return "BoolParam"; + case ContourEnum : return "Contour"; + case ControlInputEnum : return "ControlInput"; + case DatasetInputEnum : return "DatasetInput"; + case DofIndexingEnum : return "DofIndexing"; + case DoubleInputEnum : return "DoubleInput"; + case DataSetParamEnum : return "DataSetParam"; + case DoubleMatArrayParamEnum : return "DoubleMatArrayParam"; + case DoubleMatParamEnum : return "DoubleMatParam"; + case DoubleParamEnum : return "DoubleParam"; + case DoubleVecParamEnum : return "DoubleVecParam"; + case ElementEnum : return "Element"; + case ElementResultEnum : return "ElementResult"; + case ExternalResultEnum : return "ExternalResult"; + case FileParamEnum : return "FileParam"; + case HookEnum : return "Hook"; + case IcefrontEnum : return "Icefront"; + case InputEnum : return "Input"; + case IntInputEnum : return "IntInput"; + case IntParamEnum : return "IntParam"; + case IntVecParamEnum : return "IntVecParam"; + case TransientParamEnum : return "TransientParam"; + case IceFrontTypeEnum : return "IceFrontType"; + case MacAyeal2dIceFrontEnum : return "MacAyeal2dIceFront"; + case MacAyeal3dIceFrontEnum : return "MacAyeal3dIceFront"; + case MaticeEnum : return "Matice"; + case MatdamageiceEnum : return "Matdamageice"; + case MatparEnum : return "Matpar"; + case NodeEnum : return "Node"; + case NumericalfluxEnum : return "Numericalflux"; + case NumericalfluxTypeEnum : return "NumericalfluxType"; + case ParamEnum : return "Param"; + case L1L2IceFrontEnum : return "L1L2IceFront"; + case PattynIceFrontEnum : return "PattynIceFront"; + case PengridEnum : return "Pengrid"; + case PenpairEnum : return "Penpair"; + case PentaEnum : return "Penta"; + case PentaP1InputEnum : return "PentaP1Input"; + case ProfilerEnum : return "Profiler"; + case MatrixParamEnum : return "MatrixParam"; + case VectorParamEnum : return "VectorParam"; + case RiftfrontEnum : return "Riftfront"; + case RiftfrontTypeEnum : return "RiftfrontType"; + case SegmentEnum : return "Segment"; + case SegmentRiftfrontEnum : return "SegmentRiftfront"; + case SpcDynamicEnum : return "SpcDynamic"; + case SpcStaticEnum : return "SpcStatic"; + case SpcTransientEnum : return "SpcTransient"; + case StokesIceFrontEnum : return "StokesIceFront"; + case StringArrayParamEnum : return "StringArrayParam"; + case StringParamEnum : return "StringParam"; + case TriaEnum : return "Tria"; + case TriaP1InputEnum : return "TriaP1Input"; + case VertexEnum : return "Vertex"; + case AirEnum : return "Air"; + case IceEnum : return "Ice"; + case MelangeEnum : return "Melange"; + case WaterEnum : return "Water"; + case ClosedEnum : return "Closed"; + case FreeEnum : return "Free"; + case OpenEnum : return "Open"; + case AdjointpEnum : return "Adjointp"; + case AdjointxEnum : return "Adjointx"; + case AdjointyEnum : return "Adjointy"; + case AdjointzEnum : return "Adjointz"; + case BalancethicknessMisfitEnum : return "BalancethicknessMisfit"; + case BedSlopeXEnum : return "BedSlopeX"; + case BedSlopeYEnum : return "BedSlopeY"; + case BoundaryEnum : return "Boundary"; + case ConstantEnum : return "Constant"; + case ConvergedEnum : return "Converged"; + case ExtToIuEnum : return "ExtToIu"; + case FillEnum : return "Fill"; + case FractionIncrementEnum : return "FractionIncrement"; + case FrictionEnum : return "Friction"; + case GroundinglineMeltingRateEnum : return "GroundinglineMeltingRate"; + case InternalEnum : return "Internal"; + case IuToExtEnum : return "IuToExt"; + case MassFluxEnum : return "MassFlux"; + case MaxPenetrationEnum : return "MaxPenetration"; + case MeltingOffsetEnum : return "MeltingOffset"; + case MisfitEnum : return "Misfit"; + case NumberNodeToElementConnectivityEnum : return "NumberNodeToElementConnectivity"; + case PressureEnum : return "Pressure"; + case PressurePicardEnum : return "PressurePicard"; + case QmuPressureEnum : return "QmuPressure"; + case QmuVxEnum : return "QmuVx"; + case QmuVyEnum : return "QmuVy"; + case QmuVzEnum : return "QmuVz"; + case QmuThicknessEnum : return "QmuThickness"; + case QmuBedEnum : return "QmuBed"; + case QmuSurfaceEnum : return "QmuSurface"; + case QmuMeltingEnum : return "QmuMelting"; + case AndroidFrictionCoefficientEnum : return "AndroidFrictionCoefficient"; + case ResetPenaltiesEnum : return "ResetPenalties"; + case SegmentOnIceShelfEnum : return "SegmentOnIceShelf"; + case SurfaceAbsVelMisfitEnum : return "SurfaceAbsVelMisfit"; + case SurfaceAreaEnum : return "SurfaceArea"; + case SurfaceAverageVelMisfitEnum : return "SurfaceAverageVelMisfit"; + case SurfaceLogVelMisfitEnum : return "SurfaceLogVelMisfit"; + case SurfaceLogVxVyMisfitEnum : return "SurfaceLogVxVyMisfit"; + case SurfaceRelVelMisfitEnum : return "SurfaceRelVelMisfit"; + case SurfaceSlopeXEnum : return "SurfaceSlopeX"; + case SurfaceSlopeYEnum : return "SurfaceSlopeY"; + case TemperatureEnum : return "Temperature"; + case TemperatureOldEnum : return "TemperatureOld"; + case TemperaturePicardEnum : return "TemperaturePicard"; + case ThicknessAbsMisfitEnum : return "ThicknessAbsMisfit"; + case VelEnum : return "Vel"; + case VelocityEnum : return "Velocity"; + case VxAverageEnum : return "VxAverage"; + case VxEnum : return "Vx"; + case VxPicardEnum : return "VxPicard"; + case VyAverageEnum : return "VyAverage"; + case VyEnum : return "Vy"; + case VyPicardEnum : return "VyPicard"; + case VzEnum : return "Vz"; + case VzMacAyealEnum : return "VzMacAyeal"; + case VzPattynEnum : return "VzPattyn"; + case VzPicardEnum : return "VzPicard"; + case VzStokesEnum : return "VzStokes"; + case VxMeshEnum : return "VxMesh"; + case VyMeshEnum : return "VyMesh"; + case VzMeshEnum : return "VzMesh"; + case EnthalpyEnum : return "Enthalpy"; + case EnthalpyPicardEnum : return "EnthalpyPicard"; + case ThicknessAbsGradientEnum : return "ThicknessAbsGradient"; + case ThicknessAlongGradientEnum : return "ThicknessAlongGradient"; + case ThicknessAcrossGradientEnum : return "ThicknessAcrossGradient"; + case StepResponsesEnum : return "StepResponses"; + case IntMatParamEnum : return "IntMatParam"; + case RheologyBbarAbsGradientEnum : return "RheologyBbarAbsGradient"; + case DragCoefficientAbsGradientEnum : return "DragCoefficientAbsGradient"; + case TransientInputEnum : return "TransientInput"; + case WaterfractionEnum : return "Waterfraction"; + case WatercolumnEnum : return "Watercolumn"; + case BasalFrictionEnum : return "BasalFriction"; + case ViscousHeatingEnum : return "ViscousHeating"; + case QmuTemperatureEnum : return "QmuTemperature"; + case HydrologyWaterVxEnum : return "HydrologyWaterVx"; + case HydrologyWaterVyEnum : return "HydrologyWaterVy"; + case StressTensorEnum : return "StressTensor"; + case StressTensorxxEnum : return "StressTensorxx"; + case StressTensorxyEnum : return "StressTensorxy"; + case StressTensorxzEnum : return "StressTensorxz"; + case StressTensoryyEnum : return "StressTensoryy"; + case StressTensoryzEnum : return "StressTensoryz"; + case StressTensorzzEnum : return "StressTensorzz"; + case GiaOutputRatesEnum : return "GiaOutputRates"; + case GiaCrossSectionShapeEnum : return "GiaCrossSectionShape"; + case GiadWdtEnum : return "GiadWdt"; + case GiaWEnum : return "GiaW"; + case P0Enum : return "P0"; + case P1Enum : return "P1"; + case P1DGEnum : return "P1DG"; + case SaveResultsEnum : return "SaveResults"; + case BoolElementResultEnum : return "BoolElementResult"; + case BoolExternalResultEnum : return "BoolExternalResult"; + case DoubleElementResultEnum : return "DoubleElementResult"; + case DoubleExternalResultEnum : return "DoubleExternalResult"; + case DoubleMatExternalResultEnum : return "DoubleMatExternalResult"; + case IntExternalResultEnum : return "IntExternalResult"; + case JEnum : return "J"; + case PatchEnum : return "Patch"; + case PatchNodesEnum : return "PatchNodes"; + case PatchVerticesEnum : return "PatchVertices"; + case PentaP1ElementResultEnum : return "PentaP1ElementResult"; + case StringExternalResultEnum : return "StringExternalResult"; + case StepEnum : return "Step"; + case TimeEnum : return "Time"; + case TriaP1ElementResultEnum : return "TriaP1ElementResult"; + case WaterColumnOldEnum : return "WaterColumnOld"; + case MinVelEnum : return "MinVel"; + case MaxVelEnum : return "MaxVel"; + case MinVxEnum : return "MinVx"; + case MaxVxEnum : return "MaxVx"; + case MaxAbsVxEnum : return "MaxAbsVx"; + case MinVyEnum : return "MinVy"; + case MaxVyEnum : return "MaxVy"; + case MaxAbsVyEnum : return "MaxAbsVy"; + case MinVzEnum : return "MinVz"; + case MaxVzEnum : return "MaxVz"; + case MaxAbsVzEnum : return "MaxAbsVz"; + case IceVolumeEnum : return "IceVolume"; + case TotalSmbEnum : return "TotalSmb"; + case RelativeEnum : return "Relative"; + case AbsoluteEnum : return "Absolute"; + case IncrementalEnum : return "Incremental"; + case AgressiveMigrationEnum : return "AgressiveMigration"; + case NoneEnum : return "None"; + case SoftMigrationEnum : return "SoftMigration"; + case SubelementMigrationEnum : return "SubelementMigration"; + case SubelementMigration2Enum : return "SubelementMigration2"; + case GLlevelsetEnum : return "GLlevelset"; + case StokesSolverEnum : return "StokesSolver"; + case AdjointEnum : return "Adjoint"; + case ColinearEnum : return "Colinear"; + case ControlSteadyEnum : return "ControlSteady"; + case FsetEnum : return "Fset"; + case Gradient1Enum : return "Gradient1"; + case Gradient2Enum : return "Gradient2"; + case Gradient3Enum : return "Gradient3"; + case GradientEnum : return "Gradient"; + case GroundinglineMigrationEnum : return "GroundinglineMigration"; + case GsetEnum : return "Gset"; + case IndexEnum : return "Index"; + case IndexedEnum : return "Indexed"; + case IntersectEnum : return "Intersect"; + case NodalEnum : return "Nodal"; + case OldGradientEnum : return "OldGradient"; + case OutputFilePointerEnum : return "OutputFilePointer"; + case OutputFileNameEnum : return "OutputFileName"; + case LockFileNameEnum : return "LockFileName"; + case ToolkitsOptionsAnalysesEnum : return "ToolkitsOptionsAnalyses"; + case ToolkitsOptionsStringsEnum : return "ToolkitsOptionsStrings"; + case QmuErrNameEnum : return "QmuErrName"; + case QmuInNameEnum : return "QmuInName"; + case QmuOutNameEnum : return "QmuOutName"; + case RegularEnum : return "Regular"; + case ScaledEnum : return "Scaled"; + case SeparateEnum : return "Separate"; + case SsetEnum : return "Sset"; + case VerboseEnum : return "Verbose"; + case TriangleInterpEnum : return "TriangleInterp"; + case BilinearInterpEnum : return "BilinearInterp"; + case NearestInterpEnum : return "NearestInterp"; + case XYEnum : return "XY"; + case XYZPEnum : return "XYZP"; + case DenseEnum : return "Dense"; + case MpiDenseEnum : return "MpiDense"; + case SeqEnum : return "Seq"; + case MpiEnum : return "Mpi"; + case OptionEnum : return "Option"; + case GenericOptionEnum : return "GenericOption"; + case OptionCellEnum : return "OptionCell"; + case OptionCharEnum : return "OptionChar"; + case OptionStructEnum : return "OptionStruct"; + case OptionDoubleEnum : return "OptionDouble"; + case OptionLogicalEnum : return "OptionLogical"; + case PatersonEnum : return "Paterson"; + case ArrheniusEnum : return "Arrhenius"; + default : return "unknown"; + + } +} +void EnumToStringx(char** pstring,int enum_in){ + char *string = NULL; + int len = 0; + + len=strlen(EnumToStringx(enum_in)); + string=xNew(len+1); + memcpy(string,EnumToStringx(enum_in),(len+1)*sizeof(char)); + + /*Assign output pointer*/ + *pstring=string; +} Index: /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.h =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.h (revision 14958) +++ /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.h (revision 14958) @@ -0,0 +1,11 @@ +/* + * \file EnumToStringx + * \brief: convert Enum To String + */ + +#ifndef _ENUM_TO_STRINGX_ + +const char* EnumToStringx(int enum_in); +void EnumToStringx(char** string,int enum_in); + +#endif Index: /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp (revision 14958) +++ /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp (revision 14958) @@ -0,0 +1,582 @@ +/* +* \file StringToEnumx.cpp: +* \brief: output enum associated with string +* +* WARNING: DO NOT MODIFY THIS FILE +* this file has been automatically generated by Synchronize.sh +* Please read README for more information +*/ + +#include +#include "./StringToEnumx.h" +#include "../Exceptions/exceptions.h" +#include "../../EnumDefinitions/EnumDefinitions.h" + +int StringToEnumx(const char* name){ + + int stage=1; + + if(stage==1){ + if (strcmp(name,"AutodiffIsautodiff")==0) return AutodiffIsautodiffEnum; + else if (strcmp(name,"AutodiffNumDependents")==0) return AutodiffNumDependentsEnum; + else if (strcmp(name,"AutodiffNumDependentObjects")==0) return AutodiffNumDependentObjectsEnum; + else if (strcmp(name,"AutodiffDependentObjectNames")==0) return AutodiffDependentObjectNamesEnum; + else if (strcmp(name,"AutodiffDependentObjectTypes")==0) return AutodiffDependentObjectTypesEnum; + else if (strcmp(name,"AutodiffDependentObjectIndices")==0) return AutodiffDependentObjectIndicesEnum; + else if (strcmp(name,"AutodiffDependentObjects")==0) return AutodiffDependentObjectsEnum; + else if (strcmp(name,"AutodiffNumIndependents")==0) return AutodiffNumIndependentsEnum; + else if (strcmp(name,"AutodiffNumIndependentObjects")==0) return AutodiffNumIndependentObjectsEnum; + else if (strcmp(name,"AutodiffIndependentObjectNames")==0) return AutodiffIndependentObjectNamesEnum; + else if (strcmp(name,"AutodiffIndependentObjectTypes")==0) return AutodiffIndependentObjectTypesEnum; + else if (strcmp(name,"AutodiffIndependentObjects")==0) return AutodiffIndependentObjectsEnum; + else if (strcmp(name,"AutodiffJacobian")==0) return AutodiffJacobianEnum; + else if (strcmp(name,"AutodiffXp")==0) return AutodiffXpEnum; + else if (strcmp(name,"AutodiffDriver")==0) return AutodiffDriverEnum; + else if (strcmp(name,"AutodiffFosForwardIndex")==0) return AutodiffFosForwardIndexEnum; + else if (strcmp(name,"AutodiffFovForwardIndices")==0) return AutodiffFovForwardIndicesEnum; + else if (strcmp(name,"AutodiffFosReverseIndex")==0) return AutodiffFosReverseIndexEnum; + else if (strcmp(name,"AutodiffMassFluxSegmentsPresent")==0) return AutodiffMassFluxSegmentsPresentEnum; + else if (strcmp(name,"AutodiffKeep")==0) return AutodiffKeepEnum; + else if (strcmp(name,"BalancethicknessSpcthickness")==0) return BalancethicknessSpcthicknessEnum; + else if (strcmp(name,"BalancethicknessStabilization")==0) return BalancethicknessStabilizationEnum; + else if (strcmp(name,"BalancethicknessThickeningRate")==0) return BalancethicknessThickeningRateEnum; + else if (strcmp(name,"BasalforcingsGeothermalflux")==0) return BasalforcingsGeothermalfluxEnum; + else if (strcmp(name,"BasalforcingsMeltingRateCorrection")==0) return BasalforcingsMeltingRateCorrectionEnum; + else if (strcmp(name,"BasalforcingsMeltingRate")==0) return BasalforcingsMeltingRateEnum; + else if (strcmp(name,"Bathymetry")==0) return BathymetryEnum; + else if (strcmp(name,"Bed")==0) return BedEnum; + else if (strcmp(name,"ConstantsG")==0) return ConstantsGEnum; + else if (strcmp(name,"ConstantsReferencetemperature")==0) return ConstantsReferencetemperatureEnum; + else if (strcmp(name,"ConstantsYts")==0) return ConstantsYtsEnum; + else if (strcmp(name,"DependentObject")==0) return DependentObjectEnum; + else if (strcmp(name,"DiagnosticAbstol")==0) return DiagnosticAbstolEnum; + else if (strcmp(name,"DiagnosticIcefront")==0) return DiagnosticIcefrontEnum; + else if (strcmp(name,"DiagnosticIsnewton")==0) return DiagnosticIsnewtonEnum; + else if (strcmp(name,"DiagnosticMaxiter")==0) return DiagnosticMaxiterEnum; + else if (strcmp(name,"DiagnosticNumRequestedOutputs")==0) return DiagnosticNumRequestedOutputsEnum; + else if (strcmp(name,"DiagnosticPenaltyFactor")==0) return DiagnosticPenaltyFactorEnum; + else if (strcmp(name,"DiagnosticReferential")==0) return DiagnosticReferentialEnum; + else if (strcmp(name,"DiagnosticReltol")==0) return DiagnosticReltolEnum; + else if (strcmp(name,"DiagnosticRequestedOutputs")==0) return DiagnosticRequestedOutputsEnum; + else if (strcmp(name,"DiagnosticRestol")==0) return DiagnosticRestolEnum; + else if (strcmp(name,"DiagnosticRiftPenaltyLock")==0) return DiagnosticRiftPenaltyLockEnum; + else if (strcmp(name,"DiagnosticRiftPenaltyThreshold")==0) return DiagnosticRiftPenaltyThresholdEnum; + else if (strcmp(name,"DiagnosticShelfDampening")==0) return DiagnosticShelfDampeningEnum; + else if (strcmp(name,"DiagnosticSpcvx")==0) return DiagnosticSpcvxEnum; + else if (strcmp(name,"DiagnosticSpcvy")==0) return DiagnosticSpcvyEnum; + else if (strcmp(name,"DiagnosticSpcvz")==0) return DiagnosticSpcvzEnum; + else if (strcmp(name,"DiagnosticStokesreconditioning")==0) return DiagnosticStokesreconditioningEnum; + else if (strcmp(name,"DiagnosticVertexPairing")==0) return DiagnosticVertexPairingEnum; + else if (strcmp(name,"DiagnosticViscosityOvershoot")==0) return DiagnosticViscosityOvershootEnum; + else if (strcmp(name,"LoadingforceX")==0) return LoadingforceXEnum; + else if (strcmp(name,"LoadingforceY")==0) return LoadingforceYEnum; + else if (strcmp(name,"LoadingforceZ")==0) return LoadingforceZEnum; + else if (strcmp(name,"FlowequationBordermacayeal")==0) return FlowequationBordermacayealEnum; + else if (strcmp(name,"FlowequationBorderpattyn")==0) return FlowequationBorderpattynEnum; + else if (strcmp(name,"FlowequationBorderstokes")==0) return FlowequationBorderstokesEnum; + else if (strcmp(name,"FlowequationElementEquation")==0) return FlowequationElementEquationEnum; + else if (strcmp(name,"FlowequationIshutter")==0) return FlowequationIshutterEnum; + else if (strcmp(name,"FlowequationIsl1l2")==0) return FlowequationIsl1l2Enum; + else if (strcmp(name,"FlowequationIsmacayealpattyn")==0) return FlowequationIsmacayealpattynEnum; + else if (strcmp(name,"FlowequationIsstokes")==0) return FlowequationIsstokesEnum; + else if (strcmp(name,"FlowequationVertexEquation")==0) return FlowequationVertexEquationEnum; + else if (strcmp(name,"FrictionCoefficient")==0) return FrictionCoefficientEnum; + else if (strcmp(name,"FrictionP")==0) return FrictionPEnum; + else if (strcmp(name,"FrictionQ")==0) return FrictionQEnum; + else if (strcmp(name,"GeometryHydrostaticRatio")==0) return GeometryHydrostaticRatioEnum; + else if (strcmp(name,"HydrologyModel")==0) return HydrologyModelEnum; + else if (strcmp(name,"Hydrologyshreve")==0) return HydrologyshreveEnum; + else if (strcmp(name,"HydrologyshreveCR")==0) return HydrologyshreveCREnum; + else if (strcmp(name,"HydrologyshreveKn")==0) return HydrologyshreveKnEnum; + else if (strcmp(name,"HydrologyshreveN")==0) return HydrologyshreveNEnum; + else if (strcmp(name,"HydrologyshreveP")==0) return HydrologyshrevePEnum; + else if (strcmp(name,"HydrologyshreveQ")==0) return HydrologyshreveQEnum; + else if (strcmp(name,"HydrologyshreveSpcwatercolumn")==0) return HydrologyshreveSpcwatercolumnEnum; + else if (strcmp(name,"HydrologyshreveStabilization")==0) return HydrologyshreveStabilizationEnum; + else if (strcmp(name,"Hydrologydc")==0) return HydrologydcEnum; + else if (strcmp(name,"SedimentHead")==0) return SedimentHeadEnum; + else if (strcmp(name,"SedimentHeadResidual")==0) return SedimentHeadResidualEnum; + else if (strcmp(name,"EplHead")==0) return EplHeadEnum; + else if (strcmp(name,"HydrologydcSpcsedimentHead")==0) return HydrologydcSpcsedimentHeadEnum; + else if (strcmp(name,"HydrologydcSedimentCompressibility")==0) return HydrologydcSedimentCompressibilityEnum; + else if (strcmp(name,"HydrologydcSedimentPorosity")==0) return HydrologydcSedimentPorosityEnum; + else if (strcmp(name,"HydrologydcSedimentThickness")==0) return HydrologydcSedimentThicknessEnum; + else if (strcmp(name,"HydrologydcSedimentTransmitivity")==0) return HydrologydcSedimentTransmitivityEnum; + else if (strcmp(name,"HydrologydcWaterCompressibility")==0) return HydrologydcWaterCompressibilityEnum; + else if (strcmp(name,"HydrologydcSpceplHead")==0) return HydrologydcSpceplHeadEnum; + else if (strcmp(name,"HydrologydcEplCompressibility")==0) return HydrologydcEplCompressibilityEnum; + else if (strcmp(name,"HydrologydcEplPorosity")==0) return HydrologydcEplPorosityEnum; + else if (strcmp(name,"HydrologydcEplThickness")==0) return HydrologydcEplThicknessEnum; + else if (strcmp(name,"HydrologydcEplTransmitivity")==0) return HydrologydcEplTransmitivityEnum; + else if (strcmp(name,"HydrologydcIsefficientlayer")==0) return HydrologydcIsefficientlayerEnum; + else if (strcmp(name,"HydrologydcSedimentlimitFlag")==0) return HydrologydcSedimentlimitFlagEnum; + else if (strcmp(name,"HydrologydcSedimentlimit")==0) return HydrologydcSedimentlimitEnum; + else if (strcmp(name,"HydrologydcPenaltyFactor")==0) return HydrologydcPenaltyFactorEnum; + else if (strcmp(name,"HydrologyLayer")==0) return HydrologyLayerEnum; + else if (strcmp(name,"HydrologySediment")==0) return HydrologySedimentEnum; + else if (strcmp(name,"HydrologyEfficient")==0) return HydrologyEfficientEnum; + else if (strcmp(name,"HydrologySedimentKmax")==0) return HydrologySedimentKmaxEnum; + else if (strcmp(name,"IndependentObject")==0) return IndependentObjectEnum; + else if (strcmp(name,"InversionControlParameters")==0) return InversionControlParametersEnum; + else if (strcmp(name,"InversionCostFunctionThreshold")==0) return InversionCostFunctionThresholdEnum; + else if (strcmp(name,"InversionCostFunctionsCoefficients")==0) return InversionCostFunctionsCoefficientsEnum; + else if (strcmp(name,"InversionCostFunctions")==0) return InversionCostFunctionsEnum; + else if (strcmp(name,"InversionGradientOnly")==0) return InversionGradientOnlyEnum; + else if (strcmp(name,"InversionGradientScaling")==0) return InversionGradientScalingEnum; + else if (strcmp(name,"InversionIscontrol")==0) return InversionIscontrolEnum; + else if (strcmp(name,"InversionTao")==0) return InversionTaoEnum; + else if (strcmp(name,"InversionIncompleteAdjoint")==0) return InversionIncompleteAdjointEnum; + else if (strcmp(name,"InversionMaxParameters")==0) return InversionMaxParametersEnum; + else if (strcmp(name,"InversionMaxiterPerStep")==0) return InversionMaxiterPerStepEnum; + else if (strcmp(name,"InversionMinParameters")==0) return InversionMinParametersEnum; + else if (strcmp(name,"InversionNsteps")==0) return InversionNstepsEnum; + else if (strcmp(name,"InversionNumControlParameters")==0) return InversionNumControlParametersEnum; + else if (strcmp(name,"InversionNumCostFunctions")==0) return InversionNumCostFunctionsEnum; + else if (strcmp(name,"InversionStepThreshold")==0) return InversionStepThresholdEnum; + else if (strcmp(name,"InversionThicknessObs")==0) return InversionThicknessObsEnum; + else if (strcmp(name,"InversionVelObs")==0) return InversionVelObsEnum; + else if (strcmp(name,"InversionVxObs")==0) return InversionVxObsEnum; + else if (strcmp(name,"InversionVyObs")==0) return InversionVyObsEnum; + else stage=2; + } + if(stage==2){ + if (strcmp(name,"InversionVzObs")==0) return InversionVzObsEnum; + else if (strcmp(name,"MaskElementonfloatingice")==0) return MaskElementonfloatingiceEnum; + else if (strcmp(name,"MaskElementongroundedice")==0) return MaskElementongroundediceEnum; + else if (strcmp(name,"MaskElementonwater")==0) return MaskElementonwaterEnum; + else if (strcmp(name,"MaskVertexonfloatingice")==0) return MaskVertexonfloatingiceEnum; + else if (strcmp(name,"MaskVertexongroundedice")==0) return MaskVertexongroundediceEnum; + else if (strcmp(name,"MaskVertexonwater")==0) return MaskVertexonwaterEnum; + else if (strcmp(name,"MaterialsBeta")==0) return MaterialsBetaEnum; + else if (strcmp(name,"MaterialsHeatcapacity")==0) return MaterialsHeatcapacityEnum; + else if (strcmp(name,"MaterialsLatentheat")==0) return MaterialsLatentheatEnum; + else if (strcmp(name,"MaterialsMeltingpoint")==0) return MaterialsMeltingpointEnum; + else if (strcmp(name,"MaterialsMixedLayerCapacity")==0) return MaterialsMixedLayerCapacityEnum; + else if (strcmp(name,"MaterialsRheologyB")==0) return MaterialsRheologyBEnum; + else if (strcmp(name,"MaterialsRheologyBbar")==0) return MaterialsRheologyBbarEnum; + else if (strcmp(name,"MaterialsRheologyLaw")==0) return MaterialsRheologyLawEnum; + else if (strcmp(name,"MaterialsRheologyN")==0) return MaterialsRheologyNEnum; + else if (strcmp(name,"MaterialsRheologyZ")==0) return MaterialsRheologyZEnum; + else if (strcmp(name,"MaterialsRheologyZbar")==0) return MaterialsRheologyZbarEnum; + else if (strcmp(name,"MaterialsRhoIce")==0) return MaterialsRhoIceEnum; + else if (strcmp(name,"MaterialsRhoWater")==0) return MaterialsRhoWaterEnum; + else if (strcmp(name,"MaterialsRhoFreshwater")==0) return MaterialsRhoFreshwaterEnum; + else if (strcmp(name,"MaterialsMuWater")==0) return MaterialsMuWaterEnum; + else if (strcmp(name,"MaterialsThermalExchangeVelocity")==0) return MaterialsThermalExchangeVelocityEnum; + else if (strcmp(name,"MaterialsThermalconductivity")==0) return MaterialsThermalconductivityEnum; + else if (strcmp(name,"MaterialsLithosphereShearModulus")==0) return MaterialsLithosphereShearModulusEnum; + else if (strcmp(name,"MaterialsLithosphereDensity")==0) return MaterialsLithosphereDensityEnum; + else if (strcmp(name,"MaterialsMantleShearModulus")==0) return MaterialsMantleShearModulusEnum; + else if (strcmp(name,"MaterialsMantleDensity")==0) return MaterialsMantleDensityEnum; + else if (strcmp(name,"MeshAverageVertexConnectivity")==0) return MeshAverageVertexConnectivityEnum; + else if (strcmp(name,"MeshDimension")==0) return MeshDimensionEnum; + else if (strcmp(name,"MeshEdges")==0) return MeshEdgesEnum; + else if (strcmp(name,"MeshElementconnectivity")==0) return MeshElementconnectivityEnum; + else if (strcmp(name,"MeshElementonbed")==0) return MeshElementonbedEnum; + else if (strcmp(name,"MeshElementonsurface")==0) return MeshElementonsurfaceEnum; + else if (strcmp(name,"MeshElements2d")==0) return MeshElements2dEnum; + else if (strcmp(name,"MeshElements")==0) return MeshElementsEnum; + else if (strcmp(name,"MeshLowerelements")==0) return MeshLowerelementsEnum; + else if (strcmp(name,"MeshNumberofedges")==0) return MeshNumberofedgesEnum; + else if (strcmp(name,"MeshNumberofelements2d")==0) return MeshNumberofelements2dEnum; + else if (strcmp(name,"MeshNumberofelements")==0) return MeshNumberofelementsEnum; + else if (strcmp(name,"MeshNumberoflayers")==0) return MeshNumberoflayersEnum; + else if (strcmp(name,"MeshNumberofvertices2d")==0) return MeshNumberofvertices2dEnum; + else if (strcmp(name,"MeshNumberofvertices")==0) return MeshNumberofverticesEnum; + else if (strcmp(name,"MeshUpperelements")==0) return MeshUpperelementsEnum; + else if (strcmp(name,"MeshVertexonbed")==0) return MeshVertexonbedEnum; + else if (strcmp(name,"MeshVertexonsurface")==0) return MeshVertexonsurfaceEnum; + else if (strcmp(name,"MeshX")==0) return MeshXEnum; + else if (strcmp(name,"MeshY")==0) return MeshYEnum; + else if (strcmp(name,"MeshZ")==0) return MeshZEnum; + else if (strcmp(name,"MiscellaneousName")==0) return MiscellaneousNameEnum; + else if (strcmp(name,"PrognosticHydrostaticAdjustment")==0) return PrognosticHydrostaticAdjustmentEnum; + else if (strcmp(name,"PrognosticMinThickness")==0) return PrognosticMinThicknessEnum; + else if (strcmp(name,"PrognosticPenaltyFactor")==0) return PrognosticPenaltyFactorEnum; + else if (strcmp(name,"PrognosticSpcthickness")==0) return PrognosticSpcthicknessEnum; + else if (strcmp(name,"PrognosticStabilization")==0) return PrognosticStabilizationEnum; + else if (strcmp(name,"PrognosticVertexPairing")==0) return PrognosticVertexPairingEnum; + else if (strcmp(name,"PrognosticNumRequestedOutputs")==0) return PrognosticNumRequestedOutputsEnum; + else if (strcmp(name,"PrognosticRequestedOutputs")==0) return PrognosticRequestedOutputsEnum; + else if (strcmp(name,"QmuIsdakota")==0) return QmuIsdakotaEnum; + else if (strcmp(name,"MassFluxSegments")==0) return MassFluxSegmentsEnum; + else if (strcmp(name,"MassFluxSegmentsPresent")==0) return MassFluxSegmentsPresentEnum; + else if (strcmp(name,"QmuMassFluxSegmentsPresent")==0) return QmuMassFluxSegmentsPresentEnum; + else if (strcmp(name,"QmuNumberofpartitions")==0) return QmuNumberofpartitionsEnum; + else if (strcmp(name,"QmuNumberofresponses")==0) return QmuNumberofresponsesEnum; + else if (strcmp(name,"QmuPartition")==0) return QmuPartitionEnum; + else if (strcmp(name,"QmuResponsedescriptors")==0) return QmuResponsedescriptorsEnum; + else if (strcmp(name,"QmuVariabledescriptors")==0) return QmuVariabledescriptorsEnum; + else if (strcmp(name,"RiftsNumrifts")==0) return RiftsNumriftsEnum; + else if (strcmp(name,"RiftsRiftstruct")==0) return RiftsRiftstructEnum; + else if (strcmp(name,"SettingsIoGather")==0) return SettingsIoGatherEnum; + else if (strcmp(name,"SettingsLowmem")==0) return SettingsLowmemEnum; + else if (strcmp(name,"SettingsOutputFrequency")==0) return SettingsOutputFrequencyEnum; + else if (strcmp(name,"SettingsResultsAsPatches")==0) return SettingsResultsAsPatchesEnum; + else if (strcmp(name,"SettingsWaitonlock")==0) return SettingsWaitonlockEnum; + else if (strcmp(name,"SurfaceforcingsDelta18o")==0) return SurfaceforcingsDelta18oEnum; + else if (strcmp(name,"SurfaceforcingsDelta18oSurface")==0) return SurfaceforcingsDelta18oSurfaceEnum; + else if (strcmp(name,"SurfaceforcingsIsdelta18o")==0) return SurfaceforcingsIsdelta18oEnum; + else if (strcmp(name,"SurfaceforcingsPrecipitationsPresentday")==0) return SurfaceforcingsPrecipitationsPresentdayEnum; + else if (strcmp(name,"SurfaceforcingsTemperaturesPresentday")==0) return SurfaceforcingsTemperaturesPresentdayEnum; + else if (strcmp(name,"SurfaceforcingsTemperaturesLgm")==0) return SurfaceforcingsTemperaturesLgmEnum; + else if (strcmp(name,"DebugProfiling")==0) return DebugProfilingEnum; + else if (strcmp(name,"ProfilingCurrentMem")==0) return ProfilingCurrentMemEnum; + else if (strcmp(name,"ProfilingCurrentFlops")==0) return ProfilingCurrentFlopsEnum; + else if (strcmp(name,"ProfilingSolutionTime")==0) return ProfilingSolutionTimeEnum; + else if (strcmp(name,"MaxIterationConvergenceFlag")==0) return MaxIterationConvergenceFlagEnum; + else if (strcmp(name,"SteadystateMaxiter")==0) return SteadystateMaxiterEnum; + else if (strcmp(name,"SteadystateNumRequestedOutputs")==0) return SteadystateNumRequestedOutputsEnum; + else if (strcmp(name,"SteadystateReltol")==0) return SteadystateReltolEnum; + else if (strcmp(name,"SteadystateRequestedOutputs")==0) return SteadystateRequestedOutputsEnum; + else if (strcmp(name,"Surface")==0) return SurfaceEnum; + else if (strcmp(name,"SurfaceforcingsPrecipitation")==0) return SurfaceforcingsPrecipitationEnum; + else if (strcmp(name,"SurfaceforcingsMassBalance")==0) return SurfaceforcingsMassBalanceEnum; + else if (strcmp(name,"SurfaceforcingsIspdd")==0) return SurfaceforcingsIspddEnum; + else if (strcmp(name,"SurfaceforcingsDesfac")==0) return SurfaceforcingsDesfacEnum; + else if (strcmp(name,"SurfaceforcingsS0p")==0) return SurfaceforcingsS0pEnum; + else if (strcmp(name,"SurfaceforcingsIssmbgradients")==0) return SurfaceforcingsIssmbgradientsEnum; + else if (strcmp(name,"SurfaceforcingsMonthlytemperatures")==0) return SurfaceforcingsMonthlytemperaturesEnum; + else if (strcmp(name,"SurfaceforcingsHref")==0) return SurfaceforcingsHrefEnum; + else if (strcmp(name,"SurfaceforcingsSmbref")==0) return SurfaceforcingsSmbrefEnum; + else if (strcmp(name,"SurfaceforcingsBPos")==0) return SurfaceforcingsBPosEnum; + else if (strcmp(name,"SurfaceforcingsBNeg")==0) return SurfaceforcingsBNegEnum; + else if (strcmp(name,"ThermalMaxiter")==0) return ThermalMaxiterEnum; + else if (strcmp(name,"ThermalPenaltyFactor")==0) return ThermalPenaltyFactorEnum; + else if (strcmp(name,"ThermalPenaltyLock")==0) return ThermalPenaltyLockEnum; + else if (strcmp(name,"ThermalPenaltyThreshold")==0) return ThermalPenaltyThresholdEnum; + else if (strcmp(name,"ThermalSpctemperature")==0) return ThermalSpctemperatureEnum; + else if (strcmp(name,"ThermalStabilization")==0) return ThermalStabilizationEnum; + else if (strcmp(name,"ThermalIsenthalpy")==0) return ThermalIsenthalpyEnum; + else if (strcmp(name,"GiaMantleViscosity")==0) return GiaMantleViscosityEnum; + else if (strcmp(name,"GiaLithosphereThickness")==0) return GiaLithosphereThicknessEnum; + else if (strcmp(name,"Thickness")==0) return ThicknessEnum; + else if (strcmp(name,"TimesteppingStartTime")==0) return TimesteppingStartTimeEnum; + else if (strcmp(name,"TimesteppingFinalTime")==0) return TimesteppingFinalTimeEnum; + else if (strcmp(name,"TimesteppingCflCoefficient")==0) return TimesteppingCflCoefficientEnum; + else if (strcmp(name,"TimesteppingTimeAdapt")==0) return TimesteppingTimeAdaptEnum; + else if (strcmp(name,"TimesteppingTimeStep")==0) return TimesteppingTimeStepEnum; + else if (strcmp(name,"TransientIsdiagnostic")==0) return TransientIsdiagnosticEnum; + else if (strcmp(name,"TransientIsgroundingline")==0) return TransientIsgroundinglineEnum; + else if (strcmp(name,"TransientIsprognostic")==0) return TransientIsprognosticEnum; + else if (strcmp(name,"TransientIsthermal")==0) return TransientIsthermalEnum; + else stage=3; + } + if(stage==3){ + if (strcmp(name,"TransientIsgia")==0) return TransientIsgiaEnum; + else if (strcmp(name,"TransientNumRequestedOutputs")==0) return TransientNumRequestedOutputsEnum; + else if (strcmp(name,"TransientRequestedOutputs")==0) return TransientRequestedOutputsEnum; + else if (strcmp(name,"SolutionType")==0) return SolutionTypeEnum; + else if (strcmp(name,"AnalysisType")==0) return AnalysisTypeEnum; + else if (strcmp(name,"ConfigurationType")==0) return ConfigurationTypeEnum; + else if (strcmp(name,"AdjointBalancethicknessAnalysis")==0) return AdjointBalancethicknessAnalysisEnum; + else if (strcmp(name,"AdjointHorizAnalysis")==0) return AdjointHorizAnalysisEnum; + else if (strcmp(name,"AdjointSolution")==0) return AdjointSolutionEnum; + else if (strcmp(name,"AnalysisCounter")==0) return AnalysisCounterEnum; + else if (strcmp(name,"NoneAnalysis")==0) return NoneAnalysisEnum; + else if (strcmp(name,"DefaultAnalysis")==0) return DefaultAnalysisEnum; + else if (strcmp(name,"BalancethicknessAnalysis")==0) return BalancethicknessAnalysisEnum; + else if (strcmp(name,"BalancethicknessSolution")==0) return BalancethicknessSolutionEnum; + else if (strcmp(name,"WeakBalancethicknessAnalysis")==0) return WeakBalancethicknessAnalysisEnum; + else if (strcmp(name,"WeakBalancethicknessSolution")==0) return WeakBalancethicknessSolutionEnum; + else if (strcmp(name,"BedSlopeAnalysis")==0) return BedSlopeAnalysisEnum; + else if (strcmp(name,"BedSlopeSolution")==0) return BedSlopeSolutionEnum; + else if (strcmp(name,"BedSlopeXAnalysis")==0) return BedSlopeXAnalysisEnum; + else if (strcmp(name,"BedSlopeYAnalysis")==0) return BedSlopeYAnalysisEnum; + else if (strcmp(name,"DiagnosticHorizAnalysis")==0) return DiagnosticHorizAnalysisEnum; + else if (strcmp(name,"DiagnosticHutterAnalysis")==0) return DiagnosticHutterAnalysisEnum; + else if (strcmp(name,"DiagnosticSolution")==0) return DiagnosticSolutionEnum; + else if (strcmp(name,"DiagnosticVertAnalysis")==0) return DiagnosticVertAnalysisEnum; + else if (strcmp(name,"EnthalpyAnalysis")==0) return EnthalpyAnalysisEnum; + else if (strcmp(name,"EnthalpySolution")==0) return EnthalpySolutionEnum; + else if (strcmp(name,"FlaimAnalysis")==0) return FlaimAnalysisEnum; + else if (strcmp(name,"FlaimSolution")==0) return FlaimSolutionEnum; + else if (strcmp(name,"HydrologyShreveAnalysis")==0) return HydrologyShreveAnalysisEnum; + else if (strcmp(name,"HydrologyDCInefficientAnalysis")==0) return HydrologyDCInefficientAnalysisEnum; + else if (strcmp(name,"HydrologyDCEfficientAnalysis")==0) return HydrologyDCEfficientAnalysisEnum; + else if (strcmp(name,"HydrologySolution")==0) return HydrologySolutionEnum; + else if (strcmp(name,"MeltingAnalysis")==0) return MeltingAnalysisEnum; + else if (strcmp(name,"PrognosticAnalysis")==0) return PrognosticAnalysisEnum; + else if (strcmp(name,"PrognosticSolution")==0) return PrognosticSolutionEnum; + else if (strcmp(name,"SteadystateSolution")==0) return SteadystateSolutionEnum; + else if (strcmp(name,"SurfaceSlopeAnalysis")==0) return SurfaceSlopeAnalysisEnum; + else if (strcmp(name,"SurfaceSlopeSolution")==0) return SurfaceSlopeSolutionEnum; + else if (strcmp(name,"SurfaceSlopeXAnalysis")==0) return SurfaceSlopeXAnalysisEnum; + else if (strcmp(name,"SurfaceSlopeYAnalysis")==0) return SurfaceSlopeYAnalysisEnum; + else if (strcmp(name,"ThermalAnalysis")==0) return ThermalAnalysisEnum; + else if (strcmp(name,"ThermalSolution")==0) return ThermalSolutionEnum; + else if (strcmp(name,"TransientSolution")==0) return TransientSolutionEnum; + else if (strcmp(name,"GiaSolution")==0) return GiaSolutionEnum; + else if (strcmp(name,"GiaAnalysis")==0) return GiaAnalysisEnum; + else if (strcmp(name,"Approximation")==0) return ApproximationEnum; + else if (strcmp(name,"NoneApproximation")==0) return NoneApproximationEnum; + else if (strcmp(name,"HutterApproximation")==0) return HutterApproximationEnum; + else if (strcmp(name,"MacAyealApproximation")==0) return MacAyealApproximationEnum; + else if (strcmp(name,"MacAyealPattynApproximation")==0) return MacAyealPattynApproximationEnum; + else if (strcmp(name,"MacAyealStokesApproximation")==0) return MacAyealStokesApproximationEnum; + else if (strcmp(name,"L1L2Approximation")==0) return L1L2ApproximationEnum; + else if (strcmp(name,"PattynApproximation")==0) return PattynApproximationEnum; + else if (strcmp(name,"PattynStokesApproximation")==0) return PattynStokesApproximationEnum; + else if (strcmp(name,"StokesApproximation")==0) return StokesApproximationEnum; + else if (strcmp(name,"Constraints")==0) return ConstraintsEnum; + else if (strcmp(name,"Loads")==0) return LoadsEnum; + else if (strcmp(name,"Materials")==0) return MaterialsEnum; + else if (strcmp(name,"Nodes")==0) return NodesEnum; + else if (strcmp(name,"Parameters")==0) return ParametersEnum; + else if (strcmp(name,"Vertices")==0) return VerticesEnum; + else if (strcmp(name,"Results")==0) return ResultsEnum; + else if (strcmp(name,"GenericParam")==0) return GenericParamEnum; + else if (strcmp(name,"AdolcParam")==0) return AdolcParamEnum; + else if (strcmp(name,"BoolInput")==0) return BoolInputEnum; + else if (strcmp(name,"BoolParam")==0) return BoolParamEnum; + else if (strcmp(name,"Contour")==0) return ContourEnum; + else if (strcmp(name,"ControlInput")==0) return ControlInputEnum; + else if (strcmp(name,"DatasetInput")==0) return DatasetInputEnum; + else if (strcmp(name,"DofIndexing")==0) return DofIndexingEnum; + else if (strcmp(name,"DoubleInput")==0) return DoubleInputEnum; + else if (strcmp(name,"DataSetParam")==0) return DataSetParamEnum; + else if (strcmp(name,"DoubleMatArrayParam")==0) return DoubleMatArrayParamEnum; + else if (strcmp(name,"DoubleMatParam")==0) return DoubleMatParamEnum; + else if (strcmp(name,"DoubleParam")==0) return DoubleParamEnum; + else if (strcmp(name,"DoubleVecParam")==0) return DoubleVecParamEnum; + else if (strcmp(name,"Element")==0) return ElementEnum; + else if (strcmp(name,"ElementResult")==0) return ElementResultEnum; + else if (strcmp(name,"ExternalResult")==0) return ExternalResultEnum; + else if (strcmp(name,"FileParam")==0) return FileParamEnum; + else if (strcmp(name,"Hook")==0) return HookEnum; + else if (strcmp(name,"Icefront")==0) return IcefrontEnum; + else if (strcmp(name,"Input")==0) return InputEnum; + else if (strcmp(name,"IntInput")==0) return IntInputEnum; + else if (strcmp(name,"IntParam")==0) return IntParamEnum; + else if (strcmp(name,"IntVecParam")==0) return IntVecParamEnum; + else if (strcmp(name,"TransientParam")==0) return TransientParamEnum; + else if (strcmp(name,"IceFrontType")==0) return IceFrontTypeEnum; + else if (strcmp(name,"MacAyeal2dIceFront")==0) return MacAyeal2dIceFrontEnum; + else if (strcmp(name,"MacAyeal3dIceFront")==0) return MacAyeal3dIceFrontEnum; + else if (strcmp(name,"Matice")==0) return MaticeEnum; + else if (strcmp(name,"Matdamageice")==0) return MatdamageiceEnum; + else if (strcmp(name,"Matpar")==0) return MatparEnum; + else if (strcmp(name,"Node")==0) return NodeEnum; + else if (strcmp(name,"Numericalflux")==0) return NumericalfluxEnum; + else if (strcmp(name,"NumericalfluxType")==0) return NumericalfluxTypeEnum; + else if (strcmp(name,"Param")==0) return ParamEnum; + else if (strcmp(name,"L1L2IceFront")==0) return L1L2IceFrontEnum; + else if (strcmp(name,"PattynIceFront")==0) return PattynIceFrontEnum; + else if (strcmp(name,"Pengrid")==0) return PengridEnum; + else if (strcmp(name,"Penpair")==0) return PenpairEnum; + else if (strcmp(name,"Penta")==0) return PentaEnum; + else if (strcmp(name,"PentaP1Input")==0) return PentaP1InputEnum; + else if (strcmp(name,"Profiler")==0) return ProfilerEnum; + else if (strcmp(name,"MatrixParam")==0) return MatrixParamEnum; + else if (strcmp(name,"VectorParam")==0) return VectorParamEnum; + else if (strcmp(name,"Riftfront")==0) return RiftfrontEnum; + else if (strcmp(name,"RiftfrontType")==0) return RiftfrontTypeEnum; + else if (strcmp(name,"Segment")==0) return SegmentEnum; + else if (strcmp(name,"SegmentRiftfront")==0) return SegmentRiftfrontEnum; + else if (strcmp(name,"SpcDynamic")==0) return SpcDynamicEnum; + else if (strcmp(name,"SpcStatic")==0) return SpcStaticEnum; + else if (strcmp(name,"SpcTransient")==0) return SpcTransientEnum; + else if (strcmp(name,"StokesIceFront")==0) return StokesIceFrontEnum; + else if (strcmp(name,"StringArrayParam")==0) return StringArrayParamEnum; + else if (strcmp(name,"StringParam")==0) return StringParamEnum; + else if (strcmp(name,"Tria")==0) return TriaEnum; + else if (strcmp(name,"TriaP1Input")==0) return TriaP1InputEnum; + else if (strcmp(name,"Vertex")==0) return VertexEnum; + else if (strcmp(name,"Air")==0) return AirEnum; + else stage=4; + } + if(stage==4){ + if (strcmp(name,"Ice")==0) return IceEnum; + else if (strcmp(name,"Melange")==0) return MelangeEnum; + else if (strcmp(name,"Water")==0) return WaterEnum; + else if (strcmp(name,"Closed")==0) return ClosedEnum; + else if (strcmp(name,"Free")==0) return FreeEnum; + else if (strcmp(name,"Open")==0) return OpenEnum; + else if (strcmp(name,"Adjointp")==0) return AdjointpEnum; + else if (strcmp(name,"Adjointx")==0) return AdjointxEnum; + else if (strcmp(name,"Adjointy")==0) return AdjointyEnum; + else if (strcmp(name,"Adjointz")==0) return AdjointzEnum; + else if (strcmp(name,"BalancethicknessMisfit")==0) return BalancethicknessMisfitEnum; + else if (strcmp(name,"BedSlopeX")==0) return BedSlopeXEnum; + else if (strcmp(name,"BedSlopeY")==0) return BedSlopeYEnum; + else if (strcmp(name,"Boundary")==0) return BoundaryEnum; + else if (strcmp(name,"Constant")==0) return ConstantEnum; + else if (strcmp(name,"Converged")==0) return ConvergedEnum; + else if (strcmp(name,"ExtToIu")==0) return ExtToIuEnum; + else if (strcmp(name,"Fill")==0) return FillEnum; + else if (strcmp(name,"FractionIncrement")==0) return FractionIncrementEnum; + else if (strcmp(name,"Friction")==0) return FrictionEnum; + else if (strcmp(name,"GroundinglineMeltingRate")==0) return GroundinglineMeltingRateEnum; + else if (strcmp(name,"Internal")==0) return InternalEnum; + else if (strcmp(name,"IuToExt")==0) return IuToExtEnum; + else if (strcmp(name,"MassFlux")==0) return MassFluxEnum; + else if (strcmp(name,"MaxPenetration")==0) return MaxPenetrationEnum; + else if (strcmp(name,"MeltingOffset")==0) return MeltingOffsetEnum; + else if (strcmp(name,"Misfit")==0) return MisfitEnum; + else if (strcmp(name,"NumberNodeToElementConnectivity")==0) return NumberNodeToElementConnectivityEnum; + else if (strcmp(name,"Pressure")==0) return PressureEnum; + else if (strcmp(name,"PressurePicard")==0) return PressurePicardEnum; + else if (strcmp(name,"QmuPressure")==0) return QmuPressureEnum; + else if (strcmp(name,"QmuVx")==0) return QmuVxEnum; + else if (strcmp(name,"QmuVy")==0) return QmuVyEnum; + else if (strcmp(name,"QmuVz")==0) return QmuVzEnum; + else if (strcmp(name,"QmuThickness")==0) return QmuThicknessEnum; + else if (strcmp(name,"QmuBed")==0) return QmuBedEnum; + else if (strcmp(name,"QmuSurface")==0) return QmuSurfaceEnum; + else if (strcmp(name,"QmuMelting")==0) return QmuMeltingEnum; + else if (strcmp(name,"AndroidFrictionCoefficient")==0) return AndroidFrictionCoefficientEnum; + else if (strcmp(name,"ResetPenalties")==0) return ResetPenaltiesEnum; + else if (strcmp(name,"SegmentOnIceShelf")==0) return SegmentOnIceShelfEnum; + else if (strcmp(name,"SurfaceAbsVelMisfit")==0) return SurfaceAbsVelMisfitEnum; + else if (strcmp(name,"SurfaceArea")==0) return SurfaceAreaEnum; + else if (strcmp(name,"SurfaceAverageVelMisfit")==0) return SurfaceAverageVelMisfitEnum; + else if (strcmp(name,"SurfaceLogVelMisfit")==0) return SurfaceLogVelMisfitEnum; + else if (strcmp(name,"SurfaceLogVxVyMisfit")==0) return SurfaceLogVxVyMisfitEnum; + else if (strcmp(name,"SurfaceRelVelMisfit")==0) return SurfaceRelVelMisfitEnum; + else if (strcmp(name,"SurfaceSlopeX")==0) return SurfaceSlopeXEnum; + else if (strcmp(name,"SurfaceSlopeY")==0) return SurfaceSlopeYEnum; + else if (strcmp(name,"Temperature")==0) return TemperatureEnum; + else if (strcmp(name,"TemperatureOld")==0) return TemperatureOldEnum; + else if (strcmp(name,"TemperaturePicard")==0) return TemperaturePicardEnum; + else if (strcmp(name,"ThicknessAbsMisfit")==0) return ThicknessAbsMisfitEnum; + else if (strcmp(name,"Vel")==0) return VelEnum; + else if (strcmp(name,"Velocity")==0) return VelocityEnum; + else if (strcmp(name,"VxAverage")==0) return VxAverageEnum; + else if (strcmp(name,"Vx")==0) return VxEnum; + else if (strcmp(name,"VxPicard")==0) return VxPicardEnum; + else if (strcmp(name,"VyAverage")==0) return VyAverageEnum; + else if (strcmp(name,"Vy")==0) return VyEnum; + else if (strcmp(name,"VyPicard")==0) return VyPicardEnum; + else if (strcmp(name,"Vz")==0) return VzEnum; + else if (strcmp(name,"VzMacAyeal")==0) return VzMacAyealEnum; + else if (strcmp(name,"VzPattyn")==0) return VzPattynEnum; + else if (strcmp(name,"VzPicard")==0) return VzPicardEnum; + else if (strcmp(name,"VzStokes")==0) return VzStokesEnum; + else if (strcmp(name,"VxMesh")==0) return VxMeshEnum; + else if (strcmp(name,"VyMesh")==0) return VyMeshEnum; + else if (strcmp(name,"VzMesh")==0) return VzMeshEnum; + else if (strcmp(name,"Enthalpy")==0) return EnthalpyEnum; + else if (strcmp(name,"EnthalpyPicard")==0) return EnthalpyPicardEnum; + else if (strcmp(name,"ThicknessAbsGradient")==0) return ThicknessAbsGradientEnum; + else if (strcmp(name,"ThicknessAlongGradient")==0) return ThicknessAlongGradientEnum; + else if (strcmp(name,"ThicknessAcrossGradient")==0) return ThicknessAcrossGradientEnum; + else if (strcmp(name,"StepResponses")==0) return StepResponsesEnum; + else if (strcmp(name,"IntMatParam")==0) return IntMatParamEnum; + else if (strcmp(name,"RheologyBbarAbsGradient")==0) return RheologyBbarAbsGradientEnum; + else if (strcmp(name,"DragCoefficientAbsGradient")==0) return DragCoefficientAbsGradientEnum; + else if (strcmp(name,"TransientInput")==0) return TransientInputEnum; + else if (strcmp(name,"Waterfraction")==0) return WaterfractionEnum; + else if (strcmp(name,"Watercolumn")==0) return WatercolumnEnum; + else if (strcmp(name,"BasalFriction")==0) return BasalFrictionEnum; + else if (strcmp(name,"ViscousHeating")==0) return ViscousHeatingEnum; + else if (strcmp(name,"QmuTemperature")==0) return QmuTemperatureEnum; + else if (strcmp(name,"HydrologyWaterVx")==0) return HydrologyWaterVxEnum; + else if (strcmp(name,"HydrologyWaterVy")==0) return HydrologyWaterVyEnum; + else if (strcmp(name,"StressTensor")==0) return StressTensorEnum; + else if (strcmp(name,"StressTensorxx")==0) return StressTensorxxEnum; + else if (strcmp(name,"StressTensorxy")==0) return StressTensorxyEnum; + else if (strcmp(name,"StressTensorxz")==0) return StressTensorxzEnum; + else if (strcmp(name,"StressTensoryy")==0) return StressTensoryyEnum; + else if (strcmp(name,"StressTensoryz")==0) return StressTensoryzEnum; + else if (strcmp(name,"StressTensorzz")==0) return StressTensorzzEnum; + else if (strcmp(name,"GiaOutputRates")==0) return GiaOutputRatesEnum; + else if (strcmp(name,"GiaCrossSectionShape")==0) return GiaCrossSectionShapeEnum; + else if (strcmp(name,"GiadWdt")==0) return GiadWdtEnum; + else if (strcmp(name,"GiaW")==0) return GiaWEnum; + else if (strcmp(name,"P0")==0) return P0Enum; + else if (strcmp(name,"P1")==0) return P1Enum; + else if (strcmp(name,"P1DG")==0) return P1DGEnum; + else if (strcmp(name,"SaveResults")==0) return SaveResultsEnum; + else if (strcmp(name,"BoolElementResult")==0) return BoolElementResultEnum; + else if (strcmp(name,"BoolExternalResult")==0) return BoolExternalResultEnum; + else if (strcmp(name,"DoubleElementResult")==0) return DoubleElementResultEnum; + else if (strcmp(name,"DoubleExternalResult")==0) return DoubleExternalResultEnum; + else if (strcmp(name,"DoubleMatExternalResult")==0) return DoubleMatExternalResultEnum; + else if (strcmp(name,"IntExternalResult")==0) return IntExternalResultEnum; + else if (strcmp(name,"J")==0) return JEnum; + else if (strcmp(name,"Patch")==0) return PatchEnum; + else if (strcmp(name,"PatchNodes")==0) return PatchNodesEnum; + else if (strcmp(name,"PatchVertices")==0) return PatchVerticesEnum; + else if (strcmp(name,"PentaP1ElementResult")==0) return PentaP1ElementResultEnum; + else if (strcmp(name,"StringExternalResult")==0) return StringExternalResultEnum; + else if (strcmp(name,"Step")==0) return StepEnum; + else if (strcmp(name,"Time")==0) return TimeEnum; + else if (strcmp(name,"TriaP1ElementResult")==0) return TriaP1ElementResultEnum; + else if (strcmp(name,"WaterColumnOld")==0) return WaterColumnOldEnum; + else if (strcmp(name,"MinVel")==0) return MinVelEnum; + else if (strcmp(name,"MaxVel")==0) return MaxVelEnum; + else if (strcmp(name,"MinVx")==0) return MinVxEnum; + else stage=5; + } + if(stage==5){ + if (strcmp(name,"MaxVx")==0) return MaxVxEnum; + else if (strcmp(name,"MaxAbsVx")==0) return MaxAbsVxEnum; + else if (strcmp(name,"MinVy")==0) return MinVyEnum; + else if (strcmp(name,"MaxVy")==0) return MaxVyEnum; + else if (strcmp(name,"MaxAbsVy")==0) return MaxAbsVyEnum; + else if (strcmp(name,"MinVz")==0) return MinVzEnum; + else if (strcmp(name,"MaxVz")==0) return MaxVzEnum; + else if (strcmp(name,"MaxAbsVz")==0) return MaxAbsVzEnum; + else if (strcmp(name,"IceVolume")==0) return IceVolumeEnum; + else if (strcmp(name,"TotalSmb")==0) return TotalSmbEnum; + else if (strcmp(name,"Relative")==0) return RelativeEnum; + else if (strcmp(name,"Absolute")==0) return AbsoluteEnum; + else if (strcmp(name,"Incremental")==0) return IncrementalEnum; + else if (strcmp(name,"AgressiveMigration")==0) return AgressiveMigrationEnum; + else if (strcmp(name,"None")==0) return NoneEnum; + else if (strcmp(name,"SoftMigration")==0) return SoftMigrationEnum; + else if (strcmp(name,"SubelementMigration")==0) return SubelementMigrationEnum; + else if (strcmp(name,"SubelementMigration2")==0) return SubelementMigration2Enum; + else if (strcmp(name,"GLlevelset")==0) return GLlevelsetEnum; + else if (strcmp(name,"StokesSolver")==0) return StokesSolverEnum; + else if (strcmp(name,"Adjoint")==0) return AdjointEnum; + else if (strcmp(name,"Colinear")==0) return ColinearEnum; + else if (strcmp(name,"ControlSteady")==0) return ControlSteadyEnum; + else if (strcmp(name,"Fset")==0) return FsetEnum; + else if (strcmp(name,"Gradient1")==0) return Gradient1Enum; + else if (strcmp(name,"Gradient2")==0) return Gradient2Enum; + else if (strcmp(name,"Gradient3")==0) return Gradient3Enum; + else if (strcmp(name,"Gradient")==0) return GradientEnum; + else if (strcmp(name,"GroundinglineMigration")==0) return GroundinglineMigrationEnum; + else if (strcmp(name,"Gset")==0) return GsetEnum; + else if (strcmp(name,"Index")==0) return IndexEnum; + else if (strcmp(name,"Indexed")==0) return IndexedEnum; + else if (strcmp(name,"Intersect")==0) return IntersectEnum; + else if (strcmp(name,"Nodal")==0) return NodalEnum; + else if (strcmp(name,"OldGradient")==0) return OldGradientEnum; + else if (strcmp(name,"OutputFilePointer")==0) return OutputFilePointerEnum; + else if (strcmp(name,"OutputFileName")==0) return OutputFileNameEnum; + else if (strcmp(name,"LockFileName")==0) return LockFileNameEnum; + else if (strcmp(name,"ToolkitsOptionsAnalyses")==0) return ToolkitsOptionsAnalysesEnum; + else if (strcmp(name,"ToolkitsOptionsStrings")==0) return ToolkitsOptionsStringsEnum; + else if (strcmp(name,"QmuErrName")==0) return QmuErrNameEnum; + else if (strcmp(name,"QmuInName")==0) return QmuInNameEnum; + else if (strcmp(name,"QmuOutName")==0) return QmuOutNameEnum; + else if (strcmp(name,"Regular")==0) return RegularEnum; + else if (strcmp(name,"Scaled")==0) return ScaledEnum; + else if (strcmp(name,"Separate")==0) return SeparateEnum; + else if (strcmp(name,"Sset")==0) return SsetEnum; + else if (strcmp(name,"Verbose")==0) return VerboseEnum; + else if (strcmp(name,"TriangleInterp")==0) return TriangleInterpEnum; + else if (strcmp(name,"BilinearInterp")==0) return BilinearInterpEnum; + else if (strcmp(name,"NearestInterp")==0) return NearestInterpEnum; + else if (strcmp(name,"XY")==0) return XYEnum; + else if (strcmp(name,"XYZP")==0) return XYZPEnum; + else if (strcmp(name,"Dense")==0) return DenseEnum; + else if (strcmp(name,"MpiDense")==0) return MpiDenseEnum; + else if (strcmp(name,"Seq")==0) return SeqEnum; + else if (strcmp(name,"Mpi")==0) return MpiEnum; + else if (strcmp(name,"Option")==0) return OptionEnum; + else if (strcmp(name,"GenericOption")==0) return GenericOptionEnum; + else if (strcmp(name,"OptionCell")==0) return OptionCellEnum; + else if (strcmp(name,"OptionChar")==0) return OptionCharEnum; + else if (strcmp(name,"OptionStruct")==0) return OptionStructEnum; + else if (strcmp(name,"OptionDouble")==0) return OptionDoubleEnum; + else if (strcmp(name,"OptionLogical")==0) return OptionLogicalEnum; + else if (strcmp(name,"Paterson")==0) return PatersonEnum; + else if (strcmp(name,"Arrhenius")==0) return ArrheniusEnum; + else stage=6; + } + /*If we reach this point, the string provided has not been found*/ + _error_("Enum " << name << " not found"); +} Index: /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.h =================================================================== --- /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.h (revision 14958) +++ /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.h (revision 14958) @@ -0,0 +1,10 @@ +/* + * \file StringToEnumx + * \brief: convert String to Enum + */ + +#ifndef _STRING_TO_ENUMX_ + +int StringToEnumx(const char* string_in); + +#endif Index: /issm/trunk-jpl/src/c/shared/shared.h =================================================================== --- /issm/trunk-jpl/src/c/shared/shared.h (revision 14957) +++ /issm/trunk-jpl/src/c/shared/shared.h (revision 14958) @@ -9,4 +9,6 @@ #include "./Bamg/shared.h" #include "./Elements/elements.h" +#include "./Enum/EnumToStringx.h" +#include "./Enum/StringToEnumx.h" #include "./Exceptions/exceptions.h" #include "./Exp/exp.h"