Index: /issm/trunk/src/c/Container/DataSet.cpp =================================================================== --- /issm/trunk/src/c/Container/DataSet.cpp (revision 5102) +++ /issm/trunk/src/c/Container/DataSet.cpp (revision 5103) @@ -349,5 +349,5 @@ } else{ - ISSMERROR("could not recognize enum type: %i (%s)",enum_type,EnumAsString(enum_type)); + ISSMERROR("could not recognize enum type: %i (%s)",enum_type,EnumToString(enum_type)); } @@ -466,5 +466,5 @@ /*Carry out a binary search on the sorted_ids: */ if(!binary_search(&id_offset,eid, sorted_ids,objects.size())){ - ISSMERROR("could not find object with id %i in DataSet %s",eid,EnumAsString(enum_type)); + ISSMERROR("could not find object with id %i in DataSet %s",eid,EnumToString(enum_type)); } Index: /issm/trunk/src/c/Container/Inputs.cpp =================================================================== --- /issm/trunk/src/c/Container/Inputs.cpp (revision 5102) +++ /issm/trunk/src/c/Container/Inputs.cpp (revision 5103) @@ -63,5 +63,5 @@ /*we could not find an input with the correct enum type. No defaults values were provided, * error out: */ - ISSMERROR("could not find input with enum type %i (%s)",enum_type,EnumAsString(enum_type)); + ISSMERROR("could not find input with enum type %i (%s)",enum_type,EnumToString(enum_type)); } @@ -117,5 +117,5 @@ /*we could not find an input with the correct enum type. No defaults values were provided, * error out: */ - ISSMERROR("could not find input with enum type %i (%s)",enum_type,EnumAsString(enum_type)); + ISSMERROR("could not find input with enum type %i (%s)",enum_type,EnumToString(enum_type)); } @@ -145,5 +145,5 @@ /*we could not find an input with the correct enum type. No defaults values were provided, * error out: */ - ISSMERROR("could not find input with enum type %i (%s)",enum_type,EnumAsString(enum_type)); + ISSMERROR("could not find input with enum type %i (%s)",enum_type,EnumToString(enum_type)); } @@ -173,5 +173,5 @@ /*we could not find an input with the correct enum type. No defaults values were provided, * error out: */ - ISSMERROR("could not find input with enum type %i (%s)",enum_type,EnumAsString(enum_type)); + ISSMERROR("could not find input with enum type %i (%s)",enum_type,EnumToString(enum_type)); } @@ -201,5 +201,5 @@ /*we could not find an input with the correct enum type. No defaults values were provided, * error out: */ - ISSMERROR("could not find input with enum type %i (%s)",enum_type,EnumAsString(enum_type)); + ISSMERROR("could not find input with enum type %i (%s)",enum_type,EnumToString(enum_type)); } @@ -257,5 +257,5 @@ /*we could not find an input with the correct enum type. No defaults values were provided, * error out: */ - ISSMERROR("could not find input with enum type %i (%s)",enum_type,EnumAsString(enum_type)); + ISSMERROR("could not find input with enum type %i (%s)",enum_type,EnumToString(enum_type)); } @@ -285,5 +285,5 @@ /*we could not find an input with the correct enum type. No defaults values were provided, * error out: */ - ISSMERROR("could not find input with enum type %i (%s)",enum_type,EnumAsString(enum_type)); + ISSMERROR("could not find input with enum type %i (%s)",enum_type,EnumToString(enum_type)); } @@ -356,5 +356,5 @@ /*some checks: */ - if(!constrain_input) ISSMERROR(" input %s could not be found!",EnumAsString(constrain_enum)); + if(!constrain_input) ISSMERROR(" input %s could not be found!",EnumToString(constrain_enum)); /*Apply ContrainMin: */ @@ -407,5 +407,5 @@ /*Make a copy of the original input: */ original=(Input*)this->GetInput(original_enum); - if(!original)ISSMERROR("could not find input with enum: %s",EnumAsString(original_enum)); + if(!original)ISSMERROR("could not find input with enum: %s",EnumToString(original_enum)); copy=(Input*)original->copy(); @@ -454,6 +454,6 @@ /*some checks: */ - if(!xinput) ISSMERROR(" input %s could not be found!",EnumAsString(XEnum)); - if(!yinput) ISSMERROR(" input %s could not be found!",EnumAsString(YEnum)); + if(!xinput) ISSMERROR(" input %s could not be found!",EnumToString(XEnum)); + if(!yinput) ISSMERROR(" input %s could not be found!",EnumToString(YEnum)); /*Apply AXPY: */ Index: sm/trunk/src/c/EnumDefinitions/EnumAsModelField.cpp =================================================================== --- /issm/trunk/src/c/EnumDefinitions/EnumAsModelField.cpp (revision 5102) +++ (revision ) @@ -1,19 +1,0 @@ -/*\file EnumAsModelField.cpp: -* \brief: output string associated with enum, that corresponds to a model field -* for example: ThicknessEnum corresponds to model field thickness -* DragCoefficientEnum corresponds to model field drag -*/ - -#include "../shared/shared.h" -#include "../include/include.h" -#include "./EnumDefinitions.h" - -char* EnumAsModelField(int en){ - - switch(en){ - - case ThicknessEnum : return "thickness"; - case DragCoefficientEnum : return "drag_coefficient"; - default : return "unknown"; - } -} Index: sm/trunk/src/c/EnumDefinitions/EnumAsString.cpp =================================================================== --- /issm/trunk/src/c/EnumDefinitions/EnumAsString.cpp (revision 5102) +++ (revision ) @@ -1,312 +1,0 @@ -/* -* \file EnumAsString.cpp: -* \brief: output string associated with enum -* -* WARNING: DO NOT MODIFY THIS FILE -* this file has been automatically generated by SynchronizeStrings.sh -* Please read README for more information -*/ - -#include "../shared/shared.h" -#include "../include/include.h" -#include "./EnumDefinitions.h" - -char* EnumAsString(int en){ - - switch(en){ - - case ConstraintsEnum : return "Constraints"; - case DatasetsEnum : return "Datasets"; - case ElementsEnum : return "Elements"; - case LoadsEnum : return "Loads"; - case MaterialsEnum : return "Materials"; - case NodesEnum : return "Nodes"; - case ParametersEnum : return "Parameters"; - case ResultsEnum : return "Results"; - case VerticesEnum : return "Vertices"; - case SolutionTypeEnum : return "SolutionType"; - case AnalysisTypeEnum : return "AnalysisType"; - case ConfigurationTypeEnum : return "ConfigurationType"; - case SubAnalysisTypeEnum : return "SubAnalysisType"; - case AnalysisCounterEnum : return "AnalysisCounter"; - case DiagnosticSolutionEnum : return "DiagnosticSolution"; - case DiagnosticAnalysisEnum : return "DiagnosticAnalysis"; - case DiagnosticHorizAnalysisEnum : return "DiagnosticHorizAnalysis"; - case DiagnosticVertAnalysisEnum : return "DiagnosticVertAnalysis"; - case DiagnosticHutterAnalysisEnum : return "DiagnosticHutterAnalysis"; - case DiagnosticStokesAnalysisEnum : return "DiagnosticStokesAnalysis"; - case HorizAnalysisEnum : return "HorizAnalysis"; - case HutterAnalysisEnum : return "HutterAnalysis"; - case StokesAnalysisEnum : return "StokesAnalysis"; - case VertAnalysisEnum : return "VertAnalysis"; - case AdjointSolutionEnum : return "AdjointSolution"; - case AdjointHorizAnalysisEnum : return "AdjointHorizAnalysis"; - case AdjointStokesAnalysisEnum : return "AdjointStokesAnalysis"; - case ControlAnalysisEnum : return "ControlAnalysis"; - case GradientAnalysisEnum : return "GradientAnalysis"; - case InverseAnalysisEnum : return "InverseAnalysis"; - case ThermalSolutionEnum : return "ThermalSolution"; - case ThermalAnalysisEnum : return "ThermalAnalysis"; - case Transient2DSolutionEnum : return "Transient2DSolution"; - case Transient2DAnalysisEnum : return "Transient2DAnalysis"; - case Transient3DSolutionEnum : return "Transient3DSolution"; - case Transient3DAnalysisEnum : return "Transient3DAnalysis"; - case SteadyAnalysisEnum : return "SteadyAnalysis"; - case TransientAnalysisEnum : return "TransientAnalysis"; - case BedSlopeSolutionEnum : return "BedSlopeSolution"; - case BedSlopeAnalysisEnum : return "BedSlopeAnalysis"; - case SurfaceSlopeSolutionEnum : return "SurfaceSlopeSolution"; - case SurfaceSlopeAnalysisEnum : return "SurfaceSlopeAnalysis"; - case BedSlopeXAnalysisEnum : return "BedSlopeXAnalysis"; - case BedSlopeYAnalysisEnum : return "BedSlopeYAnalysis"; - case SurfaceSlopeXAnalysisEnum : return "SurfaceSlopeXAnalysis"; - case SurfaceSlopeYAnalysisEnum : return "SurfaceSlopeYAnalysis"; - case BalancedthicknessSolutionEnum : return "BalancedthicknessSolution"; - case BalancedthicknessAnalysisEnum : return "BalancedthicknessAnalysis"; - case BalancedvelocitiesSolutionEnum : return "BalancedvelocitiesSolution"; - case BalancedvelocitiesAnalysisEnum : return "BalancedvelocitiesAnalysis"; - case PrognosticSolutionEnum : return "PrognosticSolution"; - case PrognosticAnalysisEnum : return "PrognosticAnalysis"; - case MeltingAnalysisEnum : return "MeltingAnalysis"; - case ParametersSolutionEnum : return "ParametersSolution"; - case ParametersAnalysisEnum : return "ParametersAnalysis"; - case SteadystateSolutionEnum : return "SteadystateSolution"; - case SteadystateAnalysisEnum : return "SteadystateAnalysis"; - case NoneAnalysisEnum : return "NoneAnalysis"; - case FormulationEnum : return "Formulation"; - case HutterFormulationEnum : return "HutterFormulation"; - case MacAyealFormulationEnum : return "MacAyealFormulation"; - case MacAyealPattynFormulationEnum : return "MacAyealPattynFormulation"; - case NoneFormulationEnum : return "NoneFormulation"; - case PattynFormulationEnum : return "PattynFormulation"; - case StokesFormulationEnum : return "StokesFormulation"; - case ObjectEnum : return "Object"; - case HookEnum : return "Hook"; - case SegmentEnum : return "Segment"; - case ElementEnum : return "Element"; - case DofIndexingEnum : return "DofIndexing"; - case ElementPropertiesEnum : return "ElementProperties"; - case NodePropertiesEnum : return "NodeProperties"; - case PentaEnum : return "Penta"; - case TriaEnum : return "Tria"; - case NodeEnum : return "Node"; - case VertexEnum : return "Vertex"; - case LoadEnum : return "Load"; - case IcefrontEnum : return "Icefront"; - case NumericalfluxEnum : return "Numericalflux"; - case PengridEnum : return "Pengrid"; - case PenpairEnum : return "Penpair"; - case QuadIceFrontEnum : return "QuadIceFront"; - case QuadRiftFrontEnum : return "QuadRiftFront"; - case RiftfrontEnum : return "Riftfront"; - case SegmentIcefrontEnum : return "SegmentIcefront"; - case SegmentRiftfrontEnum : return "SegmentRiftfront"; - case MaterialEnum : return "Material"; - case MaticeEnum : return "Matice"; - case MatparEnum : return "Matpar"; - case InputEnum : return "Input"; - case BoolInputEnum : return "BoolInput"; - case DoubleInputEnum : return "DoubleInput"; - case IntInputEnum : return "IntInput"; - case PentaVertexInputEnum : return "PentaVertexInput"; - case TriaVertexInputEnum : return "TriaVertexInput"; - case ParamEnum : return "Param"; - case BoolParamEnum : return "BoolParam"; - case DoubleMatParamEnum : return "DoubleMatParam"; - case DoubleMatArrayParamEnum : return "DoubleMatArrayParam"; - case DoubleParamEnum : return "DoubleParam"; - case DoubleVecParamEnum : return "DoubleVecParam"; - case IntParamEnum : return "IntParam"; - case FileParamEnum : return "FileParam"; - case PetscMatParamEnum : return "PetscMatParam"; - case PetscVecParamEnum : return "PetscVecParam"; - case StringArrayParamEnum : return "StringArrayParam"; - case StringParamEnum : return "StringParam"; - case ElementResultEnum : return "ElementResult"; - case ExternalResultEnum : return "ExternalResult"; - case RgbEnum : return "Rgb"; - case SpcEnum : return "Spc"; - case GeographyEnum : return "Geography"; - case IceSheetEnum : return "IceSheet"; - case IceShelfEnum : return "IceShelf"; - case WaterEnum : return "Water"; - case IceEnum : return "Ice"; - case AirEnum : return "Air"; - case MelangeEnum : return "Melange"; - case AccumulationRateEnum : return "AccumulationRate"; - case AdjointxEnum : return "Adjointx"; - case AdjointyEnum : return "Adjointy"; - case AdjointzEnum : return "Adjointz"; - case AdjointpEnum : return "Adjointp"; - case ArtDiffEnum : return "ArtDiff"; - case BedEnum : return "Bed"; - case BedSlopeXEnum : return "BedSlopeX"; - case BedSlopeYEnum : return "BedSlopeY"; - case BoundaryEnum : return "Boundary"; - case CmMaxDmpSlopeEnum : return "CmMaxDmpSlope"; - case CmMaxDmpValueEnum : return "CmMaxDmpValue"; - case CmMinDmpSlopeEnum : return "CmMinDmpSlope"; - case CmMinDmpValueEnum : return "CmMinDmpValue"; - case CmNoiseDmpEnum : return "CmNoiseDmp"; - case CollapseEnum : return "Collapse"; - case ConstantEnum : return "Constant"; - case ControlTypeEnum : return "ControlType"; - case ConvergedEnum : return "Converged"; - case DhDtEnum : return "DhDt"; - case DragCoefficientEnum : return "DragCoefficient"; - case DragPEnum : return "DragP"; - case DragQEnum : return "DragQ"; - case DragTypeEnum : return "DragType"; - case DtEnum : return "Dt"; - case ElementOnBedEnum : return "ElementOnBed"; - case ElementOnIceShelfEnum : return "ElementOnIceShelf"; - case ElementOnSurfaceEnum : return "ElementOnSurface"; - case ElementOnWaterEnum : return "ElementOnWater"; - case EpsVelEnum : return "EpsVel"; - case FillEnum : return "Fill"; - case FitEnum : return "Fit"; - case FractionIncrementEnum : return "FractionIncrement"; - case FrictionEnum : return "Friction"; - case GeothermalFluxEnum : return "GeothermalFlux"; - case InternalEnum : return "Internal"; - case KflagEnum : return "Kflag"; - case MassFluxEnum : return "MassFlux"; - case MaxPenetrationEnum : return "MaxPenetration"; - case MeanVelEnum : return "MeanVel"; - case MeltingOffsetEnum : return "MeltingOffset"; - case MeltingRateEnum : return "MeltingRate"; - case MisfitEnum : return "Misfit"; - case NodeOnBedEnum : return "NodeOnBed"; - case NodeOnIceSheetEnum : return "NodeOnIceSheet"; - case NodeOnIceShelfEnum : return "NodeOnIceShelf"; - case NodeOnSurfaceEnum : return "NodeOnSurface"; - case NumberNodeToElementConnectivityEnum : return "NumberNodeToElementConnectivity"; - case PenaltyOffsetEnum : return "PenaltyOffset"; - case PflagEnum : return "Pflag"; - case PressureEnum : return "Pressure"; - case PressureOldEnum : return "PressureOld"; - case QmuPressureEnum : return "QmuPressure"; - case ResetPenaltiesEnum : return "ResetPenalties"; - case RheologyBEnum : return "RheologyB"; - case RheologyB2dEnum : return "RheologyB2d"; - case RheologyNEnum : return "RheologyN"; - case SegmentOnIceShelfEnum : return "SegmentOnIceShelf"; - case StabilizeConstraintsEnum : return "StabilizeConstraints"; - case StokesReconditioningEnum : return "StokesReconditioning"; - case SurfaceAreaEnum : return "SurfaceArea"; - case SurfaceEnum : return "Surface"; - case SurfaceSlopeXEnum : return "SurfaceSlopeX"; - case SurfaceSlopeYEnum : return "SurfaceSlopeY"; - case TemperatureEnum : return "Temperature"; - case TemperatureOldEnum : return "TemperatureOld"; - case ThicknessEnum : return "Thickness"; - case TypeEnum : return "Type"; - case VelEnum : return "Vel"; - case VelObsEnum : return "VelObs"; - case ViscosityOvershootEnum : return "ViscosityOvershoot"; - case VxAverageEnum : return "VxAverage"; - case VxEnum : return "Vx"; - case VxObsEnum : return "VxObs"; - case VxOldEnum : return "VxOld"; - case QmuVxEnum : return "QmuVx"; - case VyAverageEnum : return "VyAverage"; - case VyEnum : return "Vy"; - case VyObsEnum : return "VyObs"; - case VyOldEnum : return "VyOld"; - case QmuVyEnum : return "QmuVy"; - case VzAverageEnum : return "VzAverage"; - case VzEnum : return "Vz"; - case VzObsEnum : return "VzObs"; - case VzOldEnum : return "VzOld"; - case QmuVzEnum : return "QmuVz"; - case WeightsEnum : return "Weights"; - case P0Enum : return "P0"; - case P1Enum : return "P1"; - case P1DGEnum : return "P1DG"; - case MiniEnum : return "Mini"; - case DoubleElementResultEnum : return "DoubleElementResult"; - case TriaVertexElementResultEnum : return "TriaVertexElementResult"; - case PentaVertexElementResultEnum : return "PentaVertexElementResult"; - case BoolExternalResultEnum : return "BoolExternalResult"; - case DoubleExternalResultEnum : return "DoubleExternalResult"; - case DoubleVecExternalResultEnum : return "DoubleVecExternalResult"; - case DoubleMatExternalResultEnum : return "DoubleMatExternalResult"; - case IntExternalResultEnum : return "IntExternalResult"; - case PetscVecExternalResultEnum : return "PetscVecExternalResult"; - case StringExternalResultEnum : return "StringExternalResult"; - case JEnum : return "J"; - case PatchEnum : return "Patch"; - case PatchVerticesEnum : return "PatchVertices"; - case PatchNodesEnum : return "PatchNodes"; - case TimeEnum : return "Time"; - case RelativeEnum : return "Relative"; - case ResidualEnum : return "Residual"; - case AbsoluteEnum : return "Absolute"; - case RhoIceEnum : return "RhoIce"; - case RhoWaterEnum : return "RhoWater"; - case GravityEnum : return "Gravity"; - case ThermalConductivityEnum : return "ThermalConductivity"; - case MixedLayerCapacityEnum : return "MixedLayerCapacity"; - case ThermalExchangeVelocityEnum : return "ThermalExchangeVelocity"; - case IntersectEnum : return "Intersect"; - case ColinearEnum : return "Colinear"; - case SeparateEnum : return "Separate"; - case BetaEnum : return "Beta"; - case CmGradientEnum : return "CmGradient"; - case CmJumpEnum : return "CmJump"; - case CmMaxEnum : return "CmMax"; - case CmMinEnum : return "CmMin"; - case AdjointEnum : return "Adjoint"; - case GradientEnum : return "Gradient"; - case OldGradientEnum : return "OldGradient"; - case ConnectivityEnum : return "Connectivity"; - case ControlParameterEnum : return "ControlParameter"; - case ControlSteadyEnum : return "ControlSteady"; - case DakotaParameterEnum : return "DakotaParameter"; - case DimEnum : return "Dim"; - case EpsAbsEnum : return "EpsAbs"; - case EpsCmEnum : return "EpsCm"; - case EpsRelEnum : return "EpsRel"; - case EpsResEnum : return "EpsRes"; - case HeatCapacityEnum : return "HeatCapacity"; - case IsHutterEnum : return "IsHutter"; - case IsMacAyealPattynEnum : return "IsMacAyealPattyn"; - case IsStokesEnum : return "IsStokes"; - case LatentHeatEnum : return "LatentHeat"; - case LowmemEnum : return "Lowmem"; - case MaxIterEnum : return "MaxIter"; - case MaxNonlinearIterationsEnum : return "MaxNonlinearIterations"; - case MeltingPointEnum : return "MeltingPoint"; - case MinMechanicalConstraintsEnum : return "MinMechanicalConstraints"; - case MinThermalConstraintsEnum : return "MinThermalConstraints"; - case NStepsEnum : return "NSteps"; - case NdtEnum : return "Ndt"; - case NumOutputEnum : return "NumOutput"; - case NumRiftsEnum : return "NumRifts"; - case NumberOfDofsPerNodeEnum : return "NumberOfDofsPerNode"; - case NumberOfElementsEnum : return "NumberOfElements"; - case NumberOfNodesEnum : return "NumberOfNodes"; - case NumberOfVerticesEnum : return "NumberOfVertices"; - case OptScalEnum : return "OptScal"; - case OutputFilePointerEnum : return "OutputFilePointer"; - case ParameterOutputEnum : return "ParameterOutput"; - case PenaltyMeltingEnum : return "PenaltyMelting"; - case QmuAnalysisEnum : return "QmuAnalysis"; - case QmuErrNameEnum : return "QmuErrName"; - case QmuInNameEnum : return "QmuInName"; - case QmuMassFluxSegmentsEnum : return "QmuMassFluxSegments"; - case QmuNPartEnum : return "QmuNPart"; - case QmuOutNameEnum : return "QmuOutName"; - case QmuPartEnum : return "QmuPart"; - case ResponseDescriptorsEnum : return "ResponseDescriptors"; - case SolverStringEnum : return "SolverString"; - case SparsityEnum : return "Sparsity"; - case TolXEnum : return "TolX"; - case VariableDescriptorsEnum : return "VariableDescriptors"; - case VerboseEnum : return "Verbose"; - case WaitOnLockEnum : return "WaitOnLock"; - case YtsEnum : return "Yts"; - default : return "unknown"; - - } -} Index: /issm/trunk/src/c/EnumDefinitions/EnumDefinitions.h =================================================================== --- /issm/trunk/src/c/EnumDefinitions/EnumDefinitions.h (revision 5102) +++ /issm/trunk/src/c/EnumDefinitions/EnumDefinitions.h (revision 5103) @@ -351,7 +351,7 @@ int EnumIsLoad(int en); int EnumIsMaterial(int en); -char* EnumAsString(int enum_type); -int StringAsEnum(char* string); -char* EnumAsModelField(int en); +char* EnumToString(int enum_type); +int StringToEnum(char* string); +char* EnumToModelField(int en); #endif Index: /issm/trunk/src/c/EnumDefinitions/EnumToModelField.cpp =================================================================== --- /issm/trunk/src/c/EnumDefinitions/EnumToModelField.cpp (revision 5103) +++ /issm/trunk/src/c/EnumDefinitions/EnumToModelField.cpp (revision 5103) @@ -0,0 +1,19 @@ +/*\file EnumToModelField.cpp: +* \brief: output string associated with enum, that corresponds to a model field +* for example: ThicknessEnum corresponds to model field thickness +* DragCoefficientEnum corresponds to model field drag +*/ + +#include "../shared/shared.h" +#include "../include/include.h" +#include "./EnumDefinitions.h" + +char* EnumToModelField(int en){ + + switch(en){ + + case ThicknessEnum : return "thickness"; + case DragCoefficientEnum : return "drag_coefficient"; + default : return "unknown"; + } +} Index: /issm/trunk/src/c/EnumDefinitions/EnumToString.cpp =================================================================== --- /issm/trunk/src/c/EnumDefinitions/EnumToString.cpp (revision 5103) +++ /issm/trunk/src/c/EnumDefinitions/EnumToString.cpp (revision 5103) @@ -0,0 +1,312 @@ +/* +* \file EnumToString.cpp: +* \brief: output string associated with enum +* +* WARNING: DO NOT MODIFY THIS FILE +* this file has been automatically generated by SynchronizeStrings.sh +* Please read README for more information +*/ + +#include "../shared/shared.h" +#include "../include/include.h" +#include "./EnumDefinitions.h" + +char* EnumToString(int en){ + + switch(en){ + + case ConstraintsEnum : return "Constraints"; + case DatasetsEnum : return "Datasets"; + case ElementsEnum : return "Elements"; + case LoadsEnum : return "Loads"; + case MaterialsEnum : return "Materials"; + case NodesEnum : return "Nodes"; + case ParametersEnum : return "Parameters"; + case ResultsEnum : return "Results"; + case VerticesEnum : return "Vertices"; + case SolutionTypeEnum : return "SolutionType"; + case AnalysisTypeEnum : return "AnalysisType"; + case ConfigurationTypeEnum : return "ConfigurationType"; + case SubAnalysisTypeEnum : return "SubAnalysisType"; + case AnalysisCounterEnum : return "AnalysisCounter"; + case DiagnosticSolutionEnum : return "DiagnosticSolution"; + case DiagnosticAnalysisEnum : return "DiagnosticAnalysis"; + case DiagnosticHorizAnalysisEnum : return "DiagnosticHorizAnalysis"; + case DiagnosticVertAnalysisEnum : return "DiagnosticVertAnalysis"; + case DiagnosticHutterAnalysisEnum : return "DiagnosticHutterAnalysis"; + case DiagnosticStokesAnalysisEnum : return "DiagnosticStokesAnalysis"; + case HorizAnalysisEnum : return "HorizAnalysis"; + case HutterAnalysisEnum : return "HutterAnalysis"; + case StokesAnalysisEnum : return "StokesAnalysis"; + case VertAnalysisEnum : return "VertAnalysis"; + case AdjointSolutionEnum : return "AdjointSolution"; + case AdjointHorizAnalysisEnum : return "AdjointHorizAnalysis"; + case AdjointStokesAnalysisEnum : return "AdjointStokesAnalysis"; + case ControlAnalysisEnum : return "ControlAnalysis"; + case GradientAnalysisEnum : return "GradientAnalysis"; + case InverseAnalysisEnum : return "InverseAnalysis"; + case ThermalSolutionEnum : return "ThermalSolution"; + case ThermalAnalysisEnum : return "ThermalAnalysis"; + case Transient2DSolutionEnum : return "Transient2DSolution"; + case Transient2DAnalysisEnum : return "Transient2DAnalysis"; + case Transient3DSolutionEnum : return "Transient3DSolution"; + case Transient3DAnalysisEnum : return "Transient3DAnalysis"; + case SteadyAnalysisEnum : return "SteadyAnalysis"; + case TransientAnalysisEnum : return "TransientAnalysis"; + case BedSlopeSolutionEnum : return "BedSlopeSolution"; + case BedSlopeAnalysisEnum : return "BedSlopeAnalysis"; + case SurfaceSlopeSolutionEnum : return "SurfaceSlopeSolution"; + case SurfaceSlopeAnalysisEnum : return "SurfaceSlopeAnalysis"; + case BedSlopeXAnalysisEnum : return "BedSlopeXAnalysis"; + case BedSlopeYAnalysisEnum : return "BedSlopeYAnalysis"; + case SurfaceSlopeXAnalysisEnum : return "SurfaceSlopeXAnalysis"; + case SurfaceSlopeYAnalysisEnum : return "SurfaceSlopeYAnalysis"; + case BalancedthicknessSolutionEnum : return "BalancedthicknessSolution"; + case BalancedthicknessAnalysisEnum : return "BalancedthicknessAnalysis"; + case BalancedvelocitiesSolutionEnum : return "BalancedvelocitiesSolution"; + case BalancedvelocitiesAnalysisEnum : return "BalancedvelocitiesAnalysis"; + case PrognosticSolutionEnum : return "PrognosticSolution"; + case PrognosticAnalysisEnum : return "PrognosticAnalysis"; + case MeltingAnalysisEnum : return "MeltingAnalysis"; + case ParametersSolutionEnum : return "ParametersSolution"; + case ParametersAnalysisEnum : return "ParametersAnalysis"; + case SteadystateSolutionEnum : return "SteadystateSolution"; + case SteadystateAnalysisEnum : return "SteadystateAnalysis"; + case NoneAnalysisEnum : return "NoneAnalysis"; + case FormulationEnum : return "Formulation"; + case HutterFormulationEnum : return "HutterFormulation"; + case MacAyealFormulationEnum : return "MacAyealFormulation"; + case MacAyealPattynFormulationEnum : return "MacAyealPattynFormulation"; + case NoneFormulationEnum : return "NoneFormulation"; + case PattynFormulationEnum : return "PattynFormulation"; + case StokesFormulationEnum : return "StokesFormulation"; + case ObjectEnum : return "Object"; + case HookEnum : return "Hook"; + case SegmentEnum : return "Segment"; + case ElementEnum : return "Element"; + case DofIndexingEnum : return "DofIndexing"; + case ElementPropertiesEnum : return "ElementProperties"; + case NodePropertiesEnum : return "NodeProperties"; + case PentaEnum : return "Penta"; + case TriaEnum : return "Tria"; + case NodeEnum : return "Node"; + case VertexEnum : return "Vertex"; + case LoadEnum : return "Load"; + case IcefrontEnum : return "Icefront"; + case NumericalfluxEnum : return "Numericalflux"; + case PengridEnum : return "Pengrid"; + case PenpairEnum : return "Penpair"; + case QuadIceFrontEnum : return "QuadIceFront"; + case QuadRiftFrontEnum : return "QuadRiftFront"; + case RiftfrontEnum : return "Riftfront"; + case SegmentIcefrontEnum : return "SegmentIcefront"; + case SegmentRiftfrontEnum : return "SegmentRiftfront"; + case MaterialEnum : return "Material"; + case MaticeEnum : return "Matice"; + case MatparEnum : return "Matpar"; + case InputEnum : return "Input"; + case BoolInputEnum : return "BoolInput"; + case DoubleInputEnum : return "DoubleInput"; + case IntInputEnum : return "IntInput"; + case PentaVertexInputEnum : return "PentaVertexInput"; + case TriaVertexInputEnum : return "TriaVertexInput"; + case ParamEnum : return "Param"; + case BoolParamEnum : return "BoolParam"; + case DoubleMatParamEnum : return "DoubleMatParam"; + case DoubleMatArrayParamEnum : return "DoubleMatArrayParam"; + case DoubleParamEnum : return "DoubleParam"; + case DoubleVecParamEnum : return "DoubleVecParam"; + case IntParamEnum : return "IntParam"; + case FileParamEnum : return "FileParam"; + case PetscMatParamEnum : return "PetscMatParam"; + case PetscVecParamEnum : return "PetscVecParam"; + case StringArrayParamEnum : return "StringArrayParam"; + case StringParamEnum : return "StringParam"; + case ElementResultEnum : return "ElementResult"; + case ExternalResultEnum : return "ExternalResult"; + case RgbEnum : return "Rgb"; + case SpcEnum : return "Spc"; + case GeographyEnum : return "Geography"; + case IceSheetEnum : return "IceSheet"; + case IceShelfEnum : return "IceShelf"; + case WaterEnum : return "Water"; + case IceEnum : return "Ice"; + case AirEnum : return "Air"; + case MelangeEnum : return "Melange"; + case AccumulationRateEnum : return "AccumulationRate"; + case AdjointxEnum : return "Adjointx"; + case AdjointyEnum : return "Adjointy"; + case AdjointzEnum : return "Adjointz"; + case AdjointpEnum : return "Adjointp"; + case ArtDiffEnum : return "ArtDiff"; + case BedEnum : return "Bed"; + case BedSlopeXEnum : return "BedSlopeX"; + case BedSlopeYEnum : return "BedSlopeY"; + case BoundaryEnum : return "Boundary"; + case CmMaxDmpSlopeEnum : return "CmMaxDmpSlope"; + case CmMaxDmpValueEnum : return "CmMaxDmpValue"; + case CmMinDmpSlopeEnum : return "CmMinDmpSlope"; + case CmMinDmpValueEnum : return "CmMinDmpValue"; + case CmNoiseDmpEnum : return "CmNoiseDmp"; + case CollapseEnum : return "Collapse"; + case ConstantEnum : return "Constant"; + case ControlTypeEnum : return "ControlType"; + case ConvergedEnum : return "Converged"; + case DhDtEnum : return "DhDt"; + case DragCoefficientEnum : return "DragCoefficient"; + case DragPEnum : return "DragP"; + case DragQEnum : return "DragQ"; + case DragTypeEnum : return "DragType"; + case DtEnum : return "Dt"; + case ElementOnBedEnum : return "ElementOnBed"; + case ElementOnIceShelfEnum : return "ElementOnIceShelf"; + case ElementOnSurfaceEnum : return "ElementOnSurface"; + case ElementOnWaterEnum : return "ElementOnWater"; + case EpsVelEnum : return "EpsVel"; + case FillEnum : return "Fill"; + case FitEnum : return "Fit"; + case FractionIncrementEnum : return "FractionIncrement"; + case FrictionEnum : return "Friction"; + case GeothermalFluxEnum : return "GeothermalFlux"; + case InternalEnum : return "Internal"; + case KflagEnum : return "Kflag"; + case MassFluxEnum : return "MassFlux"; + case MaxPenetrationEnum : return "MaxPenetration"; + case MeanVelEnum : return "MeanVel"; + case MeltingOffsetEnum : return "MeltingOffset"; + case MeltingRateEnum : return "MeltingRate"; + case MisfitEnum : return "Misfit"; + case NodeOnBedEnum : return "NodeOnBed"; + case NodeOnIceSheetEnum : return "NodeOnIceSheet"; + case NodeOnIceShelfEnum : return "NodeOnIceShelf"; + case NodeOnSurfaceEnum : return "NodeOnSurface"; + case NumberNodeToElementConnectivityEnum : return "NumberNodeToElementConnectivity"; + case PenaltyOffsetEnum : return "PenaltyOffset"; + case PflagEnum : return "Pflag"; + case PressureEnum : return "Pressure"; + case PressureOldEnum : return "PressureOld"; + case QmuPressureEnum : return "QmuPressure"; + case ResetPenaltiesEnum : return "ResetPenalties"; + case RheologyBEnum : return "RheologyB"; + case RheologyB2dEnum : return "RheologyB2d"; + case RheologyNEnum : return "RheologyN"; + case SegmentOnIceShelfEnum : return "SegmentOnIceShelf"; + case StabilizeConstraintsEnum : return "StabilizeConstraints"; + case StokesReconditioningEnum : return "StokesReconditioning"; + case SurfaceAreaEnum : return "SurfaceArea"; + case SurfaceEnum : return "Surface"; + case SurfaceSlopeXEnum : return "SurfaceSlopeX"; + case SurfaceSlopeYEnum : return "SurfaceSlopeY"; + case TemperatureEnum : return "Temperature"; + case TemperatureOldEnum : return "TemperatureOld"; + case ThicknessEnum : return "Thickness"; + case TypeEnum : return "Type"; + case VelEnum : return "Vel"; + case VelObsEnum : return "VelObs"; + case ViscosityOvershootEnum : return "ViscosityOvershoot"; + case VxAverageEnum : return "VxAverage"; + case VxEnum : return "Vx"; + case VxObsEnum : return "VxObs"; + case VxOldEnum : return "VxOld"; + case QmuVxEnum : return "QmuVx"; + case VyAverageEnum : return "VyAverage"; + case VyEnum : return "Vy"; + case VyObsEnum : return "VyObs"; + case VyOldEnum : return "VyOld"; + case QmuVyEnum : return "QmuVy"; + case VzAverageEnum : return "VzAverage"; + case VzEnum : return "Vz"; + case VzObsEnum : return "VzObs"; + case VzOldEnum : return "VzOld"; + case QmuVzEnum : return "QmuVz"; + case WeightsEnum : return "Weights"; + case P0Enum : return "P0"; + case P1Enum : return "P1"; + case P1DGEnum : return "P1DG"; + case MiniEnum : return "Mini"; + case DoubleElementResultEnum : return "DoubleElementResult"; + case TriaVertexElementResultEnum : return "TriaVertexElementResult"; + case PentaVertexElementResultEnum : return "PentaVertexElementResult"; + case BoolExternalResultEnum : return "BoolExternalResult"; + case DoubleExternalResultEnum : return "DoubleExternalResult"; + case DoubleVecExternalResultEnum : return "DoubleVecExternalResult"; + case DoubleMatExternalResultEnum : return "DoubleMatExternalResult"; + case IntExternalResultEnum : return "IntExternalResult"; + case PetscVecExternalResultEnum : return "PetscVecExternalResult"; + case StringExternalResultEnum : return "StringExternalResult"; + case JEnum : return "J"; + case PatchEnum : return "Patch"; + case PatchVerticesEnum : return "PatchVertices"; + case PatchNodesEnum : return "PatchNodes"; + case TimeEnum : return "Time"; + case RelativeEnum : return "Relative"; + case ResidualEnum : return "Residual"; + case AbsoluteEnum : return "Absolute"; + case RhoIceEnum : return "RhoIce"; + case RhoWaterEnum : return "RhoWater"; + case GravityEnum : return "Gravity"; + case ThermalConductivityEnum : return "ThermalConductivity"; + case MixedLayerCapacityEnum : return "MixedLayerCapacity"; + case ThermalExchangeVelocityEnum : return "ThermalExchangeVelocity"; + case IntersectEnum : return "Intersect"; + case ColinearEnum : return "Colinear"; + case SeparateEnum : return "Separate"; + case BetaEnum : return "Beta"; + case CmGradientEnum : return "CmGradient"; + case CmJumpEnum : return "CmJump"; + case CmMaxEnum : return "CmMax"; + case CmMinEnum : return "CmMin"; + case AdjointEnum : return "Adjoint"; + case GradientEnum : return "Gradient"; + case OldGradientEnum : return "OldGradient"; + case ConnectivityEnum : return "Connectivity"; + case ControlParameterEnum : return "ControlParameter"; + case ControlSteadyEnum : return "ControlSteady"; + case DakotaParameterEnum : return "DakotaParameter"; + case DimEnum : return "Dim"; + case EpsAbsEnum : return "EpsAbs"; + case EpsCmEnum : return "EpsCm"; + case EpsRelEnum : return "EpsRel"; + case EpsResEnum : return "EpsRes"; + case HeatCapacityEnum : return "HeatCapacity"; + case IsHutterEnum : return "IsHutter"; + case IsMacAyealPattynEnum : return "IsMacAyealPattyn"; + case IsStokesEnum : return "IsStokes"; + case LatentHeatEnum : return "LatentHeat"; + case LowmemEnum : return "Lowmem"; + case MaxIterEnum : return "MaxIter"; + case MaxNonlinearIterationsEnum : return "MaxNonlinearIterations"; + case MeltingPointEnum : return "MeltingPoint"; + case MinMechanicalConstraintsEnum : return "MinMechanicalConstraints"; + case MinThermalConstraintsEnum : return "MinThermalConstraints"; + case NStepsEnum : return "NSteps"; + case NdtEnum : return "Ndt"; + case NumOutputEnum : return "NumOutput"; + case NumRiftsEnum : return "NumRifts"; + case NumberOfDofsPerNodeEnum : return "NumberOfDofsPerNode"; + case NumberOfElementsEnum : return "NumberOfElements"; + case NumberOfNodesEnum : return "NumberOfNodes"; + case NumberOfVerticesEnum : return "NumberOfVertices"; + case OptScalEnum : return "OptScal"; + case OutputFilePointerEnum : return "OutputFilePointer"; + case ParameterOutputEnum : return "ParameterOutput"; + case PenaltyMeltingEnum : return "PenaltyMelting"; + case QmuAnalysisEnum : return "QmuAnalysis"; + case QmuErrNameEnum : return "QmuErrName"; + case QmuInNameEnum : return "QmuInName"; + case QmuMassFluxSegmentsEnum : return "QmuMassFluxSegments"; + case QmuNPartEnum : return "QmuNPart"; + case QmuOutNameEnum : return "QmuOutName"; + case QmuPartEnum : return "QmuPart"; + case ResponseDescriptorsEnum : return "ResponseDescriptors"; + case SolverStringEnum : return "SolverString"; + case SparsityEnum : return "Sparsity"; + case TolXEnum : return "TolX"; + case VariableDescriptorsEnum : return "VariableDescriptors"; + case VerboseEnum : return "Verbose"; + case WaitOnLockEnum : return "WaitOnLock"; + case YtsEnum : return "Yts"; + default : return "unknown"; + + } +} Index: /issm/trunk/src/c/EnumDefinitions/README =================================================================== --- /issm/trunk/src/c/EnumDefinitions/README (revision 5102) +++ /issm/trunk/src/c/EnumDefinitions/README (revision 5103) @@ -1,6 +1,6 @@ DO NOT MODIFY the following files: -- StringAsEnum.cpp -- EnumAsString.cpp +- StringToEnum.cpp +- EnumToString.cpp - src/m/enum/* all these files are automatically synchronized with EnumDefinitions.h @@ -14,3 +14,3 @@ SYNCHRONIZESTRINGS -This scrpit synchronizes StringAsEnum.cpp and EnumAsString.cpp according to EnumDefinitions.h +This scrpit synchronizes StringToEnum.cpp and EnumToString.cpp according to EnumDefinitions.h Index: sm/trunk/src/c/EnumDefinitions/StringAsEnum.cpp =================================================================== --- /issm/trunk/src/c/EnumDefinitions/StringAsEnum.cpp (revision 5102) +++ (revision ) @@ -1,309 +1,0 @@ -/* -* \file StringAsEnum.cpp: -* \brief: output enum associated with string -* -* WARNING: DO NOT MODIFY THIS FILE -* this file has been automatically generated by SynchronizeStrings.sh -* Please read README for more information -*/ - -#include "../shared/shared.h" -#include "../include/include.h" -#include "./EnumDefinitions.h" - -int StringAsEnum(char* name){ - - if (strcmp(name,"Constraints")==0) return ConstraintsEnum; - else if (strcmp(name,"Datasets")==0) return DatasetsEnum; - else if (strcmp(name,"Elements")==0) return ElementsEnum; - 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,"Results")==0) return ResultsEnum; - else if (strcmp(name,"Vertices")==0) return VerticesEnum; - 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,"SubAnalysisType")==0) return SubAnalysisTypeEnum; - else if (strcmp(name,"AnalysisCounter")==0) return AnalysisCounterEnum; - else if (strcmp(name,"DiagnosticSolution")==0) return DiagnosticSolutionEnum; - else if (strcmp(name,"DiagnosticAnalysis")==0) return DiagnosticAnalysisEnum; - else if (strcmp(name,"DiagnosticHorizAnalysis")==0) return DiagnosticHorizAnalysisEnum; - else if (strcmp(name,"DiagnosticVertAnalysis")==0) return DiagnosticVertAnalysisEnum; - else if (strcmp(name,"DiagnosticHutterAnalysis")==0) return DiagnosticHutterAnalysisEnum; - else if (strcmp(name,"DiagnosticStokesAnalysis")==0) return DiagnosticStokesAnalysisEnum; - else if (strcmp(name,"HorizAnalysis")==0) return HorizAnalysisEnum; - else if (strcmp(name,"HutterAnalysis")==0) return HutterAnalysisEnum; - else if (strcmp(name,"StokesAnalysis")==0) return StokesAnalysisEnum; - else if (strcmp(name,"VertAnalysis")==0) return VertAnalysisEnum; - else if (strcmp(name,"AdjointSolution")==0) return AdjointSolutionEnum; - else if (strcmp(name,"AdjointHorizAnalysis")==0) return AdjointHorizAnalysisEnum; - else if (strcmp(name,"AdjointStokesAnalysis")==0) return AdjointStokesAnalysisEnum; - else if (strcmp(name,"ControlAnalysis")==0) return ControlAnalysisEnum; - else if (strcmp(name,"GradientAnalysis")==0) return GradientAnalysisEnum; - else if (strcmp(name,"InverseAnalysis")==0) return InverseAnalysisEnum; - else if (strcmp(name,"ThermalSolution")==0) return ThermalSolutionEnum; - else if (strcmp(name,"ThermalAnalysis")==0) return ThermalAnalysisEnum; - else if (strcmp(name,"Transient2DSolution")==0) return Transient2DSolutionEnum; - else if (strcmp(name,"Transient2DAnalysis")==0) return Transient2DAnalysisEnum; - else if (strcmp(name,"Transient3DSolution")==0) return Transient3DSolutionEnum; - else if (strcmp(name,"Transient3DAnalysis")==0) return Transient3DAnalysisEnum; - else if (strcmp(name,"SteadyAnalysis")==0) return SteadyAnalysisEnum; - else if (strcmp(name,"TransientAnalysis")==0) return TransientAnalysisEnum; - else if (strcmp(name,"BedSlopeSolution")==0) return BedSlopeSolutionEnum; - else if (strcmp(name,"BedSlopeAnalysis")==0) return BedSlopeAnalysisEnum; - else if (strcmp(name,"SurfaceSlopeSolution")==0) return SurfaceSlopeSolutionEnum; - else if (strcmp(name,"SurfaceSlopeAnalysis")==0) return SurfaceSlopeAnalysisEnum; - else if (strcmp(name,"BedSlopeXAnalysis")==0) return BedSlopeXAnalysisEnum; - else if (strcmp(name,"BedSlopeYAnalysis")==0) return BedSlopeYAnalysisEnum; - else if (strcmp(name,"SurfaceSlopeXAnalysis")==0) return SurfaceSlopeXAnalysisEnum; - else if (strcmp(name,"SurfaceSlopeYAnalysis")==0) return SurfaceSlopeYAnalysisEnum; - else if (strcmp(name,"BalancedthicknessSolution")==0) return BalancedthicknessSolutionEnum; - else if (strcmp(name,"BalancedthicknessAnalysis")==0) return BalancedthicknessAnalysisEnum; - else if (strcmp(name,"BalancedvelocitiesSolution")==0) return BalancedvelocitiesSolutionEnum; - else if (strcmp(name,"BalancedvelocitiesAnalysis")==0) return BalancedvelocitiesAnalysisEnum; - else if (strcmp(name,"PrognosticSolution")==0) return PrognosticSolutionEnum; - else if (strcmp(name,"PrognosticAnalysis")==0) return PrognosticAnalysisEnum; - else if (strcmp(name,"MeltingAnalysis")==0) return MeltingAnalysisEnum; - else if (strcmp(name,"ParametersSolution")==0) return ParametersSolutionEnum; - else if (strcmp(name,"ParametersAnalysis")==0) return ParametersAnalysisEnum; - else if (strcmp(name,"SteadystateSolution")==0) return SteadystateSolutionEnum; - else if (strcmp(name,"SteadystateAnalysis")==0) return SteadystateAnalysisEnum; - else if (strcmp(name,"NoneAnalysis")==0) return NoneAnalysisEnum; - else if (strcmp(name,"Formulation")==0) return FormulationEnum; - else if (strcmp(name,"HutterFormulation")==0) return HutterFormulationEnum; - else if (strcmp(name,"MacAyealFormulation")==0) return MacAyealFormulationEnum; - else if (strcmp(name,"MacAyealPattynFormulation")==0) return MacAyealPattynFormulationEnum; - else if (strcmp(name,"NoneFormulation")==0) return NoneFormulationEnum; - else if (strcmp(name,"PattynFormulation")==0) return PattynFormulationEnum; - else if (strcmp(name,"StokesFormulation")==0) return StokesFormulationEnum; - else if (strcmp(name,"Object")==0) return ObjectEnum; - else if (strcmp(name,"Hook")==0) return HookEnum; - else if (strcmp(name,"Segment")==0) return SegmentEnum; - else if (strcmp(name,"Element")==0) return ElementEnum; - else if (strcmp(name,"DofIndexing")==0) return DofIndexingEnum; - else if (strcmp(name,"ElementProperties")==0) return ElementPropertiesEnum; - else if (strcmp(name,"NodeProperties")==0) return NodePropertiesEnum; - else if (strcmp(name,"Penta")==0) return PentaEnum; - else if (strcmp(name,"Tria")==0) return TriaEnum; - else if (strcmp(name,"Node")==0) return NodeEnum; - else if (strcmp(name,"Vertex")==0) return VertexEnum; - else if (strcmp(name,"Load")==0) return LoadEnum; - else if (strcmp(name,"Icefront")==0) return IcefrontEnum; - else if (strcmp(name,"Numericalflux")==0) return NumericalfluxEnum; - else if (strcmp(name,"Pengrid")==0) return PengridEnum; - else if (strcmp(name,"Penpair")==0) return PenpairEnum; - else if (strcmp(name,"QuadIceFront")==0) return QuadIceFrontEnum; - else if (strcmp(name,"QuadRiftFront")==0) return QuadRiftFrontEnum; - else if (strcmp(name,"Riftfront")==0) return RiftfrontEnum; - else if (strcmp(name,"SegmentIcefront")==0) return SegmentIcefrontEnum; - else if (strcmp(name,"SegmentRiftfront")==0) return SegmentRiftfrontEnum; - else if (strcmp(name,"Material")==0) return MaterialEnum; - else if (strcmp(name,"Matice")==0) return MaticeEnum; - else if (strcmp(name,"Matpar")==0) return MatparEnum; - else if (strcmp(name,"Input")==0) return InputEnum; - else if (strcmp(name,"BoolInput")==0) return BoolInputEnum; - else if (strcmp(name,"DoubleInput")==0) return DoubleInputEnum; - else if (strcmp(name,"IntInput")==0) return IntInputEnum; - else if (strcmp(name,"PentaVertexInput")==0) return PentaVertexInputEnum; - else if (strcmp(name,"TriaVertexInput")==0) return TriaVertexInputEnum; - else if (strcmp(name,"Param")==0) return ParamEnum; - else if (strcmp(name,"BoolParam")==0) return BoolParamEnum; - else if (strcmp(name,"DoubleMatParam")==0) return DoubleMatParamEnum; - else if (strcmp(name,"DoubleMatArrayParam")==0) return DoubleMatArrayParamEnum; - else if (strcmp(name,"DoubleParam")==0) return DoubleParamEnum; - else if (strcmp(name,"DoubleVecParam")==0) return DoubleVecParamEnum; - else if (strcmp(name,"IntParam")==0) return IntParamEnum; - else if (strcmp(name,"FileParam")==0) return FileParamEnum; - else if (strcmp(name,"PetscMatParam")==0) return PetscMatParamEnum; - else if (strcmp(name,"PetscVecParam")==0) return PetscVecParamEnum; - else if (strcmp(name,"StringArrayParam")==0) return StringArrayParamEnum; - else if (strcmp(name,"StringParam")==0) return StringParamEnum; - else if (strcmp(name,"ElementResult")==0) return ElementResultEnum; - else if (strcmp(name,"ExternalResult")==0) return ExternalResultEnum; - else if (strcmp(name,"Rgb")==0) return RgbEnum; - else if (strcmp(name,"Spc")==0) return SpcEnum; - else if (strcmp(name,"Geography")==0) return GeographyEnum; - else if (strcmp(name,"IceSheet")==0) return IceSheetEnum; - else if (strcmp(name,"IceShelf")==0) return IceShelfEnum; - else if (strcmp(name,"Water")==0) return WaterEnum; - else if (strcmp(name,"Ice")==0) return IceEnum; - else if (strcmp(name,"Air")==0) return AirEnum; - else if (strcmp(name,"Melange")==0) return MelangeEnum; - else if (strcmp(name,"AccumulationRate")==0) return AccumulationRateEnum; - 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,"Adjointp")==0) return AdjointpEnum; - else if (strcmp(name,"ArtDiff")==0) return ArtDiffEnum; - else if (strcmp(name,"Bed")==0) return BedEnum; - else if (strcmp(name,"BedSlopeX")==0) return BedSlopeXEnum; - else if (strcmp(name,"BedSlopeY")==0) return BedSlopeYEnum; - else if (strcmp(name,"Boundary")==0) return BoundaryEnum; - else if (strcmp(name,"CmMaxDmpSlope")==0) return CmMaxDmpSlopeEnum; - else if (strcmp(name,"CmMaxDmpValue")==0) return CmMaxDmpValueEnum; - else if (strcmp(name,"CmMinDmpSlope")==0) return CmMinDmpSlopeEnum; - else if (strcmp(name,"CmMinDmpValue")==0) return CmMinDmpValueEnum; - else if (strcmp(name,"CmNoiseDmp")==0) return CmNoiseDmpEnum; - else if (strcmp(name,"Collapse")==0) return CollapseEnum; - else if (strcmp(name,"Constant")==0) return ConstantEnum; - else if (strcmp(name,"ControlType")==0) return ControlTypeEnum; - else if (strcmp(name,"Converged")==0) return ConvergedEnum; - else if (strcmp(name,"DhDt")==0) return DhDtEnum; - else if (strcmp(name,"DragCoefficient")==0) return DragCoefficientEnum; - else if (strcmp(name,"DragP")==0) return DragPEnum; - else if (strcmp(name,"DragQ")==0) return DragQEnum; - else if (strcmp(name,"DragType")==0) return DragTypeEnum; - else if (strcmp(name,"Dt")==0) return DtEnum; - else if (strcmp(name,"ElementOnBed")==0) return ElementOnBedEnum; - else if (strcmp(name,"ElementOnIceShelf")==0) return ElementOnIceShelfEnum; - else if (strcmp(name,"ElementOnSurface")==0) return ElementOnSurfaceEnum; - else if (strcmp(name,"ElementOnWater")==0) return ElementOnWaterEnum; - else if (strcmp(name,"EpsVel")==0) return EpsVelEnum; - else if (strcmp(name,"Fill")==0) return FillEnum; - else if (strcmp(name,"Fit")==0) return FitEnum; - else if (strcmp(name,"FractionIncrement")==0) return FractionIncrementEnum; - else if (strcmp(name,"Friction")==0) return FrictionEnum; - else if (strcmp(name,"GeothermalFlux")==0) return GeothermalFluxEnum; - else if (strcmp(name,"Internal")==0) return InternalEnum; - else if (strcmp(name,"Kflag")==0) return KflagEnum; - else if (strcmp(name,"MassFlux")==0) return MassFluxEnum; - else if (strcmp(name,"MaxPenetration")==0) return MaxPenetrationEnum; - else if (strcmp(name,"MeanVel")==0) return MeanVelEnum; - else if (strcmp(name,"MeltingOffset")==0) return MeltingOffsetEnum; - else if (strcmp(name,"MeltingRate")==0) return MeltingRateEnum; - else if (strcmp(name,"Misfit")==0) return MisfitEnum; - else if (strcmp(name,"NodeOnBed")==0) return NodeOnBedEnum; - else if (strcmp(name,"NodeOnIceSheet")==0) return NodeOnIceSheetEnum; - else if (strcmp(name,"NodeOnIceShelf")==0) return NodeOnIceShelfEnum; - else if (strcmp(name,"NodeOnSurface")==0) return NodeOnSurfaceEnum; - else if (strcmp(name,"NumberNodeToElementConnectivity")==0) return NumberNodeToElementConnectivityEnum; - else if (strcmp(name,"PenaltyOffset")==0) return PenaltyOffsetEnum; - else if (strcmp(name,"Pflag")==0) return PflagEnum; - else if (strcmp(name,"Pressure")==0) return PressureEnum; - else if (strcmp(name,"PressureOld")==0) return PressureOldEnum; - else if (strcmp(name,"QmuPressure")==0) return QmuPressureEnum; - else if (strcmp(name,"ResetPenalties")==0) return ResetPenaltiesEnum; - else if (strcmp(name,"RheologyB")==0) return RheologyBEnum; - else if (strcmp(name,"RheologyB2d")==0) return RheologyB2dEnum; - else if (strcmp(name,"RheologyN")==0) return RheologyNEnum; - else if (strcmp(name,"SegmentOnIceShelf")==0) return SegmentOnIceShelfEnum; - else if (strcmp(name,"StabilizeConstraints")==0) return StabilizeConstraintsEnum; - else if (strcmp(name,"StokesReconditioning")==0) return StokesReconditioningEnum; - else if (strcmp(name,"SurfaceArea")==0) return SurfaceAreaEnum; - else if (strcmp(name,"Surface")==0) return SurfaceEnum; - 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,"Thickness")==0) return ThicknessEnum; - else if (strcmp(name,"Type")==0) return TypeEnum; - else if (strcmp(name,"Vel")==0) return VelEnum; - else if (strcmp(name,"VelObs")==0) return VelObsEnum; - else if (strcmp(name,"ViscosityOvershoot")==0) return ViscosityOvershootEnum; - else if (strcmp(name,"VxAverage")==0) return VxAverageEnum; - else if (strcmp(name,"Vx")==0) return VxEnum; - else if (strcmp(name,"VxObs")==0) return VxObsEnum; - else if (strcmp(name,"VxOld")==0) return VxOldEnum; - else if (strcmp(name,"QmuVx")==0) return QmuVxEnum; - else if (strcmp(name,"VyAverage")==0) return VyAverageEnum; - else if (strcmp(name,"Vy")==0) return VyEnum; - else if (strcmp(name,"VyObs")==0) return VyObsEnum; - else if (strcmp(name,"VyOld")==0) return VyOldEnum; - else if (strcmp(name,"QmuVy")==0) return QmuVyEnum; - else if (strcmp(name,"VzAverage")==0) return VzAverageEnum; - else if (strcmp(name,"Vz")==0) return VzEnum; - else if (strcmp(name,"VzObs")==0) return VzObsEnum; - else if (strcmp(name,"VzOld")==0) return VzOldEnum; - else if (strcmp(name,"QmuVz")==0) return QmuVzEnum; - else if (strcmp(name,"Weights")==0) return WeightsEnum; - 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,"Mini")==0) return MiniEnum; - else if (strcmp(name,"DoubleElementResult")==0) return DoubleElementResultEnum; - else if (strcmp(name,"TriaVertexElementResult")==0) return TriaVertexElementResultEnum; - else if (strcmp(name,"PentaVertexElementResult")==0) return PentaVertexElementResultEnum; - else if (strcmp(name,"BoolExternalResult")==0) return BoolExternalResultEnum; - else if (strcmp(name,"DoubleExternalResult")==0) return DoubleExternalResultEnum; - else if (strcmp(name,"DoubleVecExternalResult")==0) return DoubleVecExternalResultEnum; - else if (strcmp(name,"DoubleMatExternalResult")==0) return DoubleMatExternalResultEnum; - else if (strcmp(name,"IntExternalResult")==0) return IntExternalResultEnum; - else if (strcmp(name,"PetscVecExternalResult")==0) return PetscVecExternalResultEnum; - else if (strcmp(name,"StringExternalResult")==0) return StringExternalResultEnum; - else if (strcmp(name,"J")==0) return JEnum; - else if (strcmp(name,"Patch")==0) return PatchEnum; - else if (strcmp(name,"PatchVertices")==0) return PatchVerticesEnum; - else if (strcmp(name,"PatchNodes")==0) return PatchNodesEnum; - else if (strcmp(name,"Time")==0) return TimeEnum; - else if (strcmp(name,"Relative")==0) return RelativeEnum; - else if (strcmp(name,"Residual")==0) return ResidualEnum; - else if (strcmp(name,"Absolute")==0) return AbsoluteEnum; - else if (strcmp(name,"RhoIce")==0) return RhoIceEnum; - else if (strcmp(name,"RhoWater")==0) return RhoWaterEnum; - else if (strcmp(name,"Gravity")==0) return GravityEnum; - else if (strcmp(name,"ThermalConductivity")==0) return ThermalConductivityEnum; - else if (strcmp(name,"MixedLayerCapacity")==0) return MixedLayerCapacityEnum; - else if (strcmp(name,"ThermalExchangeVelocity")==0) return ThermalExchangeVelocityEnum; - else if (strcmp(name,"Intersect")==0) return IntersectEnum; - else if (strcmp(name,"Colinear")==0) return ColinearEnum; - else if (strcmp(name,"Separate")==0) return SeparateEnum; - else if (strcmp(name,"Beta")==0) return BetaEnum; - else if (strcmp(name,"CmGradient")==0) return CmGradientEnum; - else if (strcmp(name,"CmJump")==0) return CmJumpEnum; - else if (strcmp(name,"CmMax")==0) return CmMaxEnum; - else if (strcmp(name,"CmMin")==0) return CmMinEnum; - else if (strcmp(name,"Adjoint")==0) return AdjointEnum; - else if (strcmp(name,"Gradient")==0) return GradientEnum; - else if (strcmp(name,"OldGradient")==0) return OldGradientEnum; - else if (strcmp(name,"Connectivity")==0) return ConnectivityEnum; - else if (strcmp(name,"ControlParameter")==0) return ControlParameterEnum; - else if (strcmp(name,"ControlSteady")==0) return ControlSteadyEnum; - else if (strcmp(name,"DakotaParameter")==0) return DakotaParameterEnum; - else if (strcmp(name,"Dim")==0) return DimEnum; - else if (strcmp(name,"EpsAbs")==0) return EpsAbsEnum; - else if (strcmp(name,"EpsCm")==0) return EpsCmEnum; - else if (strcmp(name,"EpsRel")==0) return EpsRelEnum; - else if (strcmp(name,"EpsRes")==0) return EpsResEnum; - else if (strcmp(name,"HeatCapacity")==0) return HeatCapacityEnum; - else if (strcmp(name,"IsHutter")==0) return IsHutterEnum; - else if (strcmp(name,"IsMacAyealPattyn")==0) return IsMacAyealPattynEnum; - else if (strcmp(name,"IsStokes")==0) return IsStokesEnum; - else if (strcmp(name,"LatentHeat")==0) return LatentHeatEnum; - else if (strcmp(name,"Lowmem")==0) return LowmemEnum; - else if (strcmp(name,"MaxIter")==0) return MaxIterEnum; - else if (strcmp(name,"MaxNonlinearIterations")==0) return MaxNonlinearIterationsEnum; - else if (strcmp(name,"MeltingPoint")==0) return MeltingPointEnum; - else if (strcmp(name,"MinMechanicalConstraints")==0) return MinMechanicalConstraintsEnum; - else if (strcmp(name,"MinThermalConstraints")==0) return MinThermalConstraintsEnum; - else if (strcmp(name,"NSteps")==0) return NStepsEnum; - else if (strcmp(name,"Ndt")==0) return NdtEnum; - else if (strcmp(name,"NumOutput")==0) return NumOutputEnum; - else if (strcmp(name,"NumRifts")==0) return NumRiftsEnum; - else if (strcmp(name,"NumberOfDofsPerNode")==0) return NumberOfDofsPerNodeEnum; - else if (strcmp(name,"NumberOfElements")==0) return NumberOfElementsEnum; - else if (strcmp(name,"NumberOfNodes")==0) return NumberOfNodesEnum; - else if (strcmp(name,"NumberOfVertices")==0) return NumberOfVerticesEnum; - else if (strcmp(name,"OptScal")==0) return OptScalEnum; - else if (strcmp(name,"OutputFilePointer")==0) return OutputFilePointerEnum; - else if (strcmp(name,"ParameterOutput")==0) return ParameterOutputEnum; - else if (strcmp(name,"PenaltyMelting")==0) return PenaltyMeltingEnum; - else if (strcmp(name,"QmuAnalysis")==0) return QmuAnalysisEnum; - else if (strcmp(name,"QmuErrName")==0) return QmuErrNameEnum; - else if (strcmp(name,"QmuInName")==0) return QmuInNameEnum; - else if (strcmp(name,"QmuMassFluxSegments")==0) return QmuMassFluxSegmentsEnum; - else if (strcmp(name,"QmuNPart")==0) return QmuNPartEnum; - else if (strcmp(name,"QmuOutName")==0) return QmuOutNameEnum; - else if (strcmp(name,"QmuPart")==0) return QmuPartEnum; - else if (strcmp(name,"ResponseDescriptors")==0) return ResponseDescriptorsEnum; - else if (strcmp(name,"SolverString")==0) return SolverStringEnum; - else if (strcmp(name,"Sparsity")==0) return SparsityEnum; - else if (strcmp(name,"TolX")==0) return TolXEnum; - else if (strcmp(name,"VariableDescriptors")==0) return VariableDescriptorsEnum; - else if (strcmp(name,"Verbose")==0) return VerboseEnum; - else if (strcmp(name,"WaitOnLock")==0) return WaitOnLockEnum; - else if (strcmp(name,"Yts")==0) return YtsEnum; - else ISSMERROR("Enum %s not found",name); - -} Index: /issm/trunk/src/c/EnumDefinitions/StringToEnum.cpp =================================================================== --- /issm/trunk/src/c/EnumDefinitions/StringToEnum.cpp (revision 5103) +++ /issm/trunk/src/c/EnumDefinitions/StringToEnum.cpp (revision 5103) @@ -0,0 +1,309 @@ +/* +* \file StringToEnum.cpp: +* \brief: output enum associated with string +* +* WARNING: DO NOT MODIFY THIS FILE +* this file has been automatically generated by SynchronizeStrings.sh +* Please read README for more information +*/ + +#include "../shared/shared.h" +#include "../include/include.h" +#include "./EnumDefinitions.h" + +int StringToEnum(char* name){ + + if (strcmp(name,"Constraints")==0) return ConstraintsEnum; + else if (strcmp(name,"Datasets")==0) return DatasetsEnum; + else if (strcmp(name,"Elements")==0) return ElementsEnum; + 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,"Results")==0) return ResultsEnum; + else if (strcmp(name,"Vertices")==0) return VerticesEnum; + 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,"SubAnalysisType")==0) return SubAnalysisTypeEnum; + else if (strcmp(name,"AnalysisCounter")==0) return AnalysisCounterEnum; + else if (strcmp(name,"DiagnosticSolution")==0) return DiagnosticSolutionEnum; + else if (strcmp(name,"DiagnosticAnalysis")==0) return DiagnosticAnalysisEnum; + else if (strcmp(name,"DiagnosticHorizAnalysis")==0) return DiagnosticHorizAnalysisEnum; + else if (strcmp(name,"DiagnosticVertAnalysis")==0) return DiagnosticVertAnalysisEnum; + else if (strcmp(name,"DiagnosticHutterAnalysis")==0) return DiagnosticHutterAnalysisEnum; + else if (strcmp(name,"DiagnosticStokesAnalysis")==0) return DiagnosticStokesAnalysisEnum; + else if (strcmp(name,"HorizAnalysis")==0) return HorizAnalysisEnum; + else if (strcmp(name,"HutterAnalysis")==0) return HutterAnalysisEnum; + else if (strcmp(name,"StokesAnalysis")==0) return StokesAnalysisEnum; + else if (strcmp(name,"VertAnalysis")==0) return VertAnalysisEnum; + else if (strcmp(name,"AdjointSolution")==0) return AdjointSolutionEnum; + else if (strcmp(name,"AdjointHorizAnalysis")==0) return AdjointHorizAnalysisEnum; + else if (strcmp(name,"AdjointStokesAnalysis")==0) return AdjointStokesAnalysisEnum; + else if (strcmp(name,"ControlAnalysis")==0) return ControlAnalysisEnum; + else if (strcmp(name,"GradientAnalysis")==0) return GradientAnalysisEnum; + else if (strcmp(name,"InverseAnalysis")==0) return InverseAnalysisEnum; + else if (strcmp(name,"ThermalSolution")==0) return ThermalSolutionEnum; + else if (strcmp(name,"ThermalAnalysis")==0) return ThermalAnalysisEnum; + else if (strcmp(name,"Transient2DSolution")==0) return Transient2DSolutionEnum; + else if (strcmp(name,"Transient2DAnalysis")==0) return Transient2DAnalysisEnum; + else if (strcmp(name,"Transient3DSolution")==0) return Transient3DSolutionEnum; + else if (strcmp(name,"Transient3DAnalysis")==0) return Transient3DAnalysisEnum; + else if (strcmp(name,"SteadyAnalysis")==0) return SteadyAnalysisEnum; + else if (strcmp(name,"TransientAnalysis")==0) return TransientAnalysisEnum; + else if (strcmp(name,"BedSlopeSolution")==0) return BedSlopeSolutionEnum; + else if (strcmp(name,"BedSlopeAnalysis")==0) return BedSlopeAnalysisEnum; + else if (strcmp(name,"SurfaceSlopeSolution")==0) return SurfaceSlopeSolutionEnum; + else if (strcmp(name,"SurfaceSlopeAnalysis")==0) return SurfaceSlopeAnalysisEnum; + else if (strcmp(name,"BedSlopeXAnalysis")==0) return BedSlopeXAnalysisEnum; + else if (strcmp(name,"BedSlopeYAnalysis")==0) return BedSlopeYAnalysisEnum; + else if (strcmp(name,"SurfaceSlopeXAnalysis")==0) return SurfaceSlopeXAnalysisEnum; + else if (strcmp(name,"SurfaceSlopeYAnalysis")==0) return SurfaceSlopeYAnalysisEnum; + else if (strcmp(name,"BalancedthicknessSolution")==0) return BalancedthicknessSolutionEnum; + else if (strcmp(name,"BalancedthicknessAnalysis")==0) return BalancedthicknessAnalysisEnum; + else if (strcmp(name,"BalancedvelocitiesSolution")==0) return BalancedvelocitiesSolutionEnum; + else if (strcmp(name,"BalancedvelocitiesAnalysis")==0) return BalancedvelocitiesAnalysisEnum; + else if (strcmp(name,"PrognosticSolution")==0) return PrognosticSolutionEnum; + else if (strcmp(name,"PrognosticAnalysis")==0) return PrognosticAnalysisEnum; + else if (strcmp(name,"MeltingAnalysis")==0) return MeltingAnalysisEnum; + else if (strcmp(name,"ParametersSolution")==0) return ParametersSolutionEnum; + else if (strcmp(name,"ParametersAnalysis")==0) return ParametersAnalysisEnum; + else if (strcmp(name,"SteadystateSolution")==0) return SteadystateSolutionEnum; + else if (strcmp(name,"SteadystateAnalysis")==0) return SteadystateAnalysisEnum; + else if (strcmp(name,"NoneAnalysis")==0) return NoneAnalysisEnum; + else if (strcmp(name,"Formulation")==0) return FormulationEnum; + else if (strcmp(name,"HutterFormulation")==0) return HutterFormulationEnum; + else if (strcmp(name,"MacAyealFormulation")==0) return MacAyealFormulationEnum; + else if (strcmp(name,"MacAyealPattynFormulation")==0) return MacAyealPattynFormulationEnum; + else if (strcmp(name,"NoneFormulation")==0) return NoneFormulationEnum; + else if (strcmp(name,"PattynFormulation")==0) return PattynFormulationEnum; + else if (strcmp(name,"StokesFormulation")==0) return StokesFormulationEnum; + else if (strcmp(name,"Object")==0) return ObjectEnum; + else if (strcmp(name,"Hook")==0) return HookEnum; + else if (strcmp(name,"Segment")==0) return SegmentEnum; + else if (strcmp(name,"Element")==0) return ElementEnum; + else if (strcmp(name,"DofIndexing")==0) return DofIndexingEnum; + else if (strcmp(name,"ElementProperties")==0) return ElementPropertiesEnum; + else if (strcmp(name,"NodeProperties")==0) return NodePropertiesEnum; + else if (strcmp(name,"Penta")==0) return PentaEnum; + else if (strcmp(name,"Tria")==0) return TriaEnum; + else if (strcmp(name,"Node")==0) return NodeEnum; + else if (strcmp(name,"Vertex")==0) return VertexEnum; + else if (strcmp(name,"Load")==0) return LoadEnum; + else if (strcmp(name,"Icefront")==0) return IcefrontEnum; + else if (strcmp(name,"Numericalflux")==0) return NumericalfluxEnum; + else if (strcmp(name,"Pengrid")==0) return PengridEnum; + else if (strcmp(name,"Penpair")==0) return PenpairEnum; + else if (strcmp(name,"QuadIceFront")==0) return QuadIceFrontEnum; + else if (strcmp(name,"QuadRiftFront")==0) return QuadRiftFrontEnum; + else if (strcmp(name,"Riftfront")==0) return RiftfrontEnum; + else if (strcmp(name,"SegmentIcefront")==0) return SegmentIcefrontEnum; + else if (strcmp(name,"SegmentRiftfront")==0) return SegmentRiftfrontEnum; + else if (strcmp(name,"Material")==0) return MaterialEnum; + else if (strcmp(name,"Matice")==0) return MaticeEnum; + else if (strcmp(name,"Matpar")==0) return MatparEnum; + else if (strcmp(name,"Input")==0) return InputEnum; + else if (strcmp(name,"BoolInput")==0) return BoolInputEnum; + else if (strcmp(name,"DoubleInput")==0) return DoubleInputEnum; + else if (strcmp(name,"IntInput")==0) return IntInputEnum; + else if (strcmp(name,"PentaVertexInput")==0) return PentaVertexInputEnum; + else if (strcmp(name,"TriaVertexInput")==0) return TriaVertexInputEnum; + else if (strcmp(name,"Param")==0) return ParamEnum; + else if (strcmp(name,"BoolParam")==0) return BoolParamEnum; + else if (strcmp(name,"DoubleMatParam")==0) return DoubleMatParamEnum; + else if (strcmp(name,"DoubleMatArrayParam")==0) return DoubleMatArrayParamEnum; + else if (strcmp(name,"DoubleParam")==0) return DoubleParamEnum; + else if (strcmp(name,"DoubleVecParam")==0) return DoubleVecParamEnum; + else if (strcmp(name,"IntParam")==0) return IntParamEnum; + else if (strcmp(name,"FileParam")==0) return FileParamEnum; + else if (strcmp(name,"PetscMatParam")==0) return PetscMatParamEnum; + else if (strcmp(name,"PetscVecParam")==0) return PetscVecParamEnum; + else if (strcmp(name,"StringArrayParam")==0) return StringArrayParamEnum; + else if (strcmp(name,"StringParam")==0) return StringParamEnum; + else if (strcmp(name,"ElementResult")==0) return ElementResultEnum; + else if (strcmp(name,"ExternalResult")==0) return ExternalResultEnum; + else if (strcmp(name,"Rgb")==0) return RgbEnum; + else if (strcmp(name,"Spc")==0) return SpcEnum; + else if (strcmp(name,"Geography")==0) return GeographyEnum; + else if (strcmp(name,"IceSheet")==0) return IceSheetEnum; + else if (strcmp(name,"IceShelf")==0) return IceShelfEnum; + else if (strcmp(name,"Water")==0) return WaterEnum; + else if (strcmp(name,"Ice")==0) return IceEnum; + else if (strcmp(name,"Air")==0) return AirEnum; + else if (strcmp(name,"Melange")==0) return MelangeEnum; + else if (strcmp(name,"AccumulationRate")==0) return AccumulationRateEnum; + 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,"Adjointp")==0) return AdjointpEnum; + else if (strcmp(name,"ArtDiff")==0) return ArtDiffEnum; + else if (strcmp(name,"Bed")==0) return BedEnum; + else if (strcmp(name,"BedSlopeX")==0) return BedSlopeXEnum; + else if (strcmp(name,"BedSlopeY")==0) return BedSlopeYEnum; + else if (strcmp(name,"Boundary")==0) return BoundaryEnum; + else if (strcmp(name,"CmMaxDmpSlope")==0) return CmMaxDmpSlopeEnum; + else if (strcmp(name,"CmMaxDmpValue")==0) return CmMaxDmpValueEnum; + else if (strcmp(name,"CmMinDmpSlope")==0) return CmMinDmpSlopeEnum; + else if (strcmp(name,"CmMinDmpValue")==0) return CmMinDmpValueEnum; + else if (strcmp(name,"CmNoiseDmp")==0) return CmNoiseDmpEnum; + else if (strcmp(name,"Collapse")==0) return CollapseEnum; + else if (strcmp(name,"Constant")==0) return ConstantEnum; + else if (strcmp(name,"ControlType")==0) return ControlTypeEnum; + else if (strcmp(name,"Converged")==0) return ConvergedEnum; + else if (strcmp(name,"DhDt")==0) return DhDtEnum; + else if (strcmp(name,"DragCoefficient")==0) return DragCoefficientEnum; + else if (strcmp(name,"DragP")==0) return DragPEnum; + else if (strcmp(name,"DragQ")==0) return DragQEnum; + else if (strcmp(name,"DragType")==0) return DragTypeEnum; + else if (strcmp(name,"Dt")==0) return DtEnum; + else if (strcmp(name,"ElementOnBed")==0) return ElementOnBedEnum; + else if (strcmp(name,"ElementOnIceShelf")==0) return ElementOnIceShelfEnum; + else if (strcmp(name,"ElementOnSurface")==0) return ElementOnSurfaceEnum; + else if (strcmp(name,"ElementOnWater")==0) return ElementOnWaterEnum; + else if (strcmp(name,"EpsVel")==0) return EpsVelEnum; + else if (strcmp(name,"Fill")==0) return FillEnum; + else if (strcmp(name,"Fit")==0) return FitEnum; + else if (strcmp(name,"FractionIncrement")==0) return FractionIncrementEnum; + else if (strcmp(name,"Friction")==0) return FrictionEnum; + else if (strcmp(name,"GeothermalFlux")==0) return GeothermalFluxEnum; + else if (strcmp(name,"Internal")==0) return InternalEnum; + else if (strcmp(name,"Kflag")==0) return KflagEnum; + else if (strcmp(name,"MassFlux")==0) return MassFluxEnum; + else if (strcmp(name,"MaxPenetration")==0) return MaxPenetrationEnum; + else if (strcmp(name,"MeanVel")==0) return MeanVelEnum; + else if (strcmp(name,"MeltingOffset")==0) return MeltingOffsetEnum; + else if (strcmp(name,"MeltingRate")==0) return MeltingRateEnum; + else if (strcmp(name,"Misfit")==0) return MisfitEnum; + else if (strcmp(name,"NodeOnBed")==0) return NodeOnBedEnum; + else if (strcmp(name,"NodeOnIceSheet")==0) return NodeOnIceSheetEnum; + else if (strcmp(name,"NodeOnIceShelf")==0) return NodeOnIceShelfEnum; + else if (strcmp(name,"NodeOnSurface")==0) return NodeOnSurfaceEnum; + else if (strcmp(name,"NumberNodeToElementConnectivity")==0) return NumberNodeToElementConnectivityEnum; + else if (strcmp(name,"PenaltyOffset")==0) return PenaltyOffsetEnum; + else if (strcmp(name,"Pflag")==0) return PflagEnum; + else if (strcmp(name,"Pressure")==0) return PressureEnum; + else if (strcmp(name,"PressureOld")==0) return PressureOldEnum; + else if (strcmp(name,"QmuPressure")==0) return QmuPressureEnum; + else if (strcmp(name,"ResetPenalties")==0) return ResetPenaltiesEnum; + else if (strcmp(name,"RheologyB")==0) return RheologyBEnum; + else if (strcmp(name,"RheologyB2d")==0) return RheologyB2dEnum; + else if (strcmp(name,"RheologyN")==0) return RheologyNEnum; + else if (strcmp(name,"SegmentOnIceShelf")==0) return SegmentOnIceShelfEnum; + else if (strcmp(name,"StabilizeConstraints")==0) return StabilizeConstraintsEnum; + else if (strcmp(name,"StokesReconditioning")==0) return StokesReconditioningEnum; + else if (strcmp(name,"SurfaceArea")==0) return SurfaceAreaEnum; + else if (strcmp(name,"Surface")==0) return SurfaceEnum; + 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,"Thickness")==0) return ThicknessEnum; + else if (strcmp(name,"Type")==0) return TypeEnum; + else if (strcmp(name,"Vel")==0) return VelEnum; + else if (strcmp(name,"VelObs")==0) return VelObsEnum; + else if (strcmp(name,"ViscosityOvershoot")==0) return ViscosityOvershootEnum; + else if (strcmp(name,"VxAverage")==0) return VxAverageEnum; + else if (strcmp(name,"Vx")==0) return VxEnum; + else if (strcmp(name,"VxObs")==0) return VxObsEnum; + else if (strcmp(name,"VxOld")==0) return VxOldEnum; + else if (strcmp(name,"QmuVx")==0) return QmuVxEnum; + else if (strcmp(name,"VyAverage")==0) return VyAverageEnum; + else if (strcmp(name,"Vy")==0) return VyEnum; + else if (strcmp(name,"VyObs")==0) return VyObsEnum; + else if (strcmp(name,"VyOld")==0) return VyOldEnum; + else if (strcmp(name,"QmuVy")==0) return QmuVyEnum; + else if (strcmp(name,"VzAverage")==0) return VzAverageEnum; + else if (strcmp(name,"Vz")==0) return VzEnum; + else if (strcmp(name,"VzObs")==0) return VzObsEnum; + else if (strcmp(name,"VzOld")==0) return VzOldEnum; + else if (strcmp(name,"QmuVz")==0) return QmuVzEnum; + else if (strcmp(name,"Weights")==0) return WeightsEnum; + 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,"Mini")==0) return MiniEnum; + else if (strcmp(name,"DoubleElementResult")==0) return DoubleElementResultEnum; + else if (strcmp(name,"TriaVertexElementResult")==0) return TriaVertexElementResultEnum; + else if (strcmp(name,"PentaVertexElementResult")==0) return PentaVertexElementResultEnum; + else if (strcmp(name,"BoolExternalResult")==0) return BoolExternalResultEnum; + else if (strcmp(name,"DoubleExternalResult")==0) return DoubleExternalResultEnum; + else if (strcmp(name,"DoubleVecExternalResult")==0) return DoubleVecExternalResultEnum; + else if (strcmp(name,"DoubleMatExternalResult")==0) return DoubleMatExternalResultEnum; + else if (strcmp(name,"IntExternalResult")==0) return IntExternalResultEnum; + else if (strcmp(name,"PetscVecExternalResult")==0) return PetscVecExternalResultEnum; + else if (strcmp(name,"StringExternalResult")==0) return StringExternalResultEnum; + else if (strcmp(name,"J")==0) return JEnum; + else if (strcmp(name,"Patch")==0) return PatchEnum; + else if (strcmp(name,"PatchVertices")==0) return PatchVerticesEnum; + else if (strcmp(name,"PatchNodes")==0) return PatchNodesEnum; + else if (strcmp(name,"Time")==0) return TimeEnum; + else if (strcmp(name,"Relative")==0) return RelativeEnum; + else if (strcmp(name,"Residual")==0) return ResidualEnum; + else if (strcmp(name,"Absolute")==0) return AbsoluteEnum; + else if (strcmp(name,"RhoIce")==0) return RhoIceEnum; + else if (strcmp(name,"RhoWater")==0) return RhoWaterEnum; + else if (strcmp(name,"Gravity")==0) return GravityEnum; + else if (strcmp(name,"ThermalConductivity")==0) return ThermalConductivityEnum; + else if (strcmp(name,"MixedLayerCapacity")==0) return MixedLayerCapacityEnum; + else if (strcmp(name,"ThermalExchangeVelocity")==0) return ThermalExchangeVelocityEnum; + else if (strcmp(name,"Intersect")==0) return IntersectEnum; + else if (strcmp(name,"Colinear")==0) return ColinearEnum; + else if (strcmp(name,"Separate")==0) return SeparateEnum; + else if (strcmp(name,"Beta")==0) return BetaEnum; + else if (strcmp(name,"CmGradient")==0) return CmGradientEnum; + else if (strcmp(name,"CmJump")==0) return CmJumpEnum; + else if (strcmp(name,"CmMax")==0) return CmMaxEnum; + else if (strcmp(name,"CmMin")==0) return CmMinEnum; + else if (strcmp(name,"Adjoint")==0) return AdjointEnum; + else if (strcmp(name,"Gradient")==0) return GradientEnum; + else if (strcmp(name,"OldGradient")==0) return OldGradientEnum; + else if (strcmp(name,"Connectivity")==0) return ConnectivityEnum; + else if (strcmp(name,"ControlParameter")==0) return ControlParameterEnum; + else if (strcmp(name,"ControlSteady")==0) return ControlSteadyEnum; + else if (strcmp(name,"DakotaParameter")==0) return DakotaParameterEnum; + else if (strcmp(name,"Dim")==0) return DimEnum; + else if (strcmp(name,"EpsAbs")==0) return EpsAbsEnum; + else if (strcmp(name,"EpsCm")==0) return EpsCmEnum; + else if (strcmp(name,"EpsRel")==0) return EpsRelEnum; + else if (strcmp(name,"EpsRes")==0) return EpsResEnum; + else if (strcmp(name,"HeatCapacity")==0) return HeatCapacityEnum; + else if (strcmp(name,"IsHutter")==0) return IsHutterEnum; + else if (strcmp(name,"IsMacAyealPattyn")==0) return IsMacAyealPattynEnum; + else if (strcmp(name,"IsStokes")==0) return IsStokesEnum; + else if (strcmp(name,"LatentHeat")==0) return LatentHeatEnum; + else if (strcmp(name,"Lowmem")==0) return LowmemEnum; + else if (strcmp(name,"MaxIter")==0) return MaxIterEnum; + else if (strcmp(name,"MaxNonlinearIterations")==0) return MaxNonlinearIterationsEnum; + else if (strcmp(name,"MeltingPoint")==0) return MeltingPointEnum; + else if (strcmp(name,"MinMechanicalConstraints")==0) return MinMechanicalConstraintsEnum; + else if (strcmp(name,"MinThermalConstraints")==0) return MinThermalConstraintsEnum; + else if (strcmp(name,"NSteps")==0) return NStepsEnum; + else if (strcmp(name,"Ndt")==0) return NdtEnum; + else if (strcmp(name,"NumOutput")==0) return NumOutputEnum; + else if (strcmp(name,"NumRifts")==0) return NumRiftsEnum; + else if (strcmp(name,"NumberOfDofsPerNode")==0) return NumberOfDofsPerNodeEnum; + else if (strcmp(name,"NumberOfElements")==0) return NumberOfElementsEnum; + else if (strcmp(name,"NumberOfNodes")==0) return NumberOfNodesEnum; + else if (strcmp(name,"NumberOfVertices")==0) return NumberOfVerticesEnum; + else if (strcmp(name,"OptScal")==0) return OptScalEnum; + else if (strcmp(name,"OutputFilePointer")==0) return OutputFilePointerEnum; + else if (strcmp(name,"ParameterOutput")==0) return ParameterOutputEnum; + else if (strcmp(name,"PenaltyMelting")==0) return PenaltyMeltingEnum; + else if (strcmp(name,"QmuAnalysis")==0) return QmuAnalysisEnum; + else if (strcmp(name,"QmuErrName")==0) return QmuErrNameEnum; + else if (strcmp(name,"QmuInName")==0) return QmuInNameEnum; + else if (strcmp(name,"QmuMassFluxSegments")==0) return QmuMassFluxSegmentsEnum; + else if (strcmp(name,"QmuNPart")==0) return QmuNPartEnum; + else if (strcmp(name,"QmuOutName")==0) return QmuOutNameEnum; + else if (strcmp(name,"QmuPart")==0) return QmuPartEnum; + else if (strcmp(name,"ResponseDescriptors")==0) return ResponseDescriptorsEnum; + else if (strcmp(name,"SolverString")==0) return SolverStringEnum; + else if (strcmp(name,"Sparsity")==0) return SparsityEnum; + else if (strcmp(name,"TolX")==0) return TolXEnum; + else if (strcmp(name,"VariableDescriptors")==0) return VariableDescriptorsEnum; + else if (strcmp(name,"Verbose")==0) return VerboseEnum; + else if (strcmp(name,"WaitOnLock")==0) return WaitOnLockEnum; + else if (strcmp(name,"Yts")==0) return YtsEnum; + else ISSMERROR("Enum %s not found",name); + +} Index: /issm/trunk/src/c/EnumDefinitions/SynchronizeMatlabEnum.sh =================================================================== --- /issm/trunk/src/c/EnumDefinitions/SynchronizeMatlabEnum.sh (revision 5102) +++ /issm/trunk/src/c/EnumDefinitions/SynchronizeMatlabEnum.sh (revision 5103) @@ -9,9 +9,9 @@ echo "Synchronizing Matlab's Enums..." #Get all lines of EnumDefinitions2.h which hold Enum | remove all comas | add line number in the first column > put everything in file temp -cat EnumDefinitions.h | grep -e "[0-9]Enum" -e "[Aa-Zz]Enum" | grep -v StringAsEnum | sed -e "s/,//g" | awk '{ printf "%s %s\n", NR, $0 }' > temp +cat EnumDefinitions.h | grep -e "[0-9]Enum" -e "[Aa-Zz]Enum" | grep -v StringToEnum | sed -e "s/,//g" | awk '{ printf "%s %s\n", NR, $0 }' > temp -#Build header of EnumAsString.m {{{1 -cat < EnumAsString.m -function string=EnumAsString(enum) +#Build header of EnumToString.m {{{1 +cat < EnumToString.m +function string=EnumToString(enum) %ENUMASSTRING - output string associated with enum % @@ -21,5 +21,5 @@ % % Usage: -% string=EnumAsString(enum) +% string=EnumToString(enum) switch enum, @@ -27,7 +27,7 @@ END #}}} -#Build header of StringAsEnum.m {{{1 -cat < StringAsEnum.m -function enum=StringAsEnum(name) +#Build header of StringToEnum.m {{{1 +cat < StringToEnum.m +function enum=StringToEnum(name) %STRINGASENUM - output enum associated with string % @@ -37,5 +37,5 @@ % % Usage: -% enum=StringAsEnum(name) +% enum=StringToEnum(name) END @@ -86,17 +86,17 @@ END #}}} -#Add case to EnumAsString.m {{{ -cat <> EnumAsString.m +#Add case to EnumToString.m {{{ +cat <> EnumToString.m case $NAMEENUM(), string='$NAME'; return END #}}} - #Add case to StringAsEnum.m {{{ + #Add case to StringToEnum.m {{{ if [ $i -eq 1 ] then - cat <> StringAsEnum.m + cat <> StringToEnum.m if (strcmpi(name,'$NAME')), enum=$NAMEENUM(); return END else - cat <> StringAsEnum.m + cat <> StringToEnum.m elseif (strcmpi(name,'$NAME')), enum=$NAMEENUM(); return END @@ -106,6 +106,6 @@ done -#Add footer of of EnumAsString.m{{{1 -cat <> EnumAsString.m +#Add footer of of EnumToString.m{{{1 +cat <> EnumToString.m otherwise, error(['Enum ' num2str(enum) ' not found']); @@ -113,6 +113,6 @@ END #}}} -#Add footer of of StringAsEnum.m{{{1 -cat <> StringAsEnum.m +#Add footer of of StringToEnum.m{{{1 +cat <> StringToEnum.m else error(['Enum ' name ' not found']); @@ -122,6 +122,6 @@ #clean up{{{ -mv StringAsEnum.m $ISSM_DIR/src/m/enum/ -mv EnumAsString.m $ISSM_DIR/src/m/enum/ +mv StringToEnum.m $ISSM_DIR/src/m/enum/ +mv EnumToString.m $ISSM_DIR/src/m/enum/ rm temp #}}} Index: /issm/trunk/src/c/EnumDefinitions/SynchronizeStrings.sh =================================================================== --- /issm/trunk/src/c/EnumDefinitions/SynchronizeStrings.sh (revision 5102) +++ /issm/trunk/src/c/EnumDefinitions/SynchronizeStrings.sh (revision 5103) @@ -1,16 +1,16 @@ #!/bin/bash -#Synchronize EnumAsString.cpp and StringAsEnum.cpp +#Synchronize EnumToString.cpp and StringToEnum.cpp #first remove existing files -rm EnumAsString.cpp StringAsEnum.cpp +rm EnumToString.cpp StringToEnum.cpp -echo "Synchronizing EnumAsString..." +echo "Synchronizing EnumToString..." #Get all lines of EnumDefinitions2.h which hold Enum | remove all comas | add line number in the first column > put everything in file temp -cat EnumDefinitions.h | grep -e "[0-9]Enum" -e "[Aa-Zz]Enum" | grep -v StringAsEnum | sed -e "s/,//g" | awk '{ printf "%s %s\n", NR, $0 }' > temp +cat EnumDefinitions.h | grep -e "[0-9]Enum" -e "[Aa-Zz]Enum" | grep -v StringToEnum | sed -e "s/,//g" | awk '{ printf "%s %s\n", NR, $0 }' > temp -#Build header of EnumAsString.cpp {{{1 -cat < EnumAsString.cpp +#Build header of EnumToString.cpp {{{1 +cat < EnumToString.cpp /* -* \file EnumAsString.cpp: +* \file EnumToString.cpp: * \brief: output string associated with enum * @@ -24,5 +24,5 @@ #include "./EnumDefinitions.h" -char* EnumAsString(int en){ +char* EnumToString(int en){ switch(en){ @@ -30,8 +30,8 @@ END #}}} -#Build header of StringAsEnum.cpp {{{1 -cat < StringAsEnum.cpp +#Build header of StringToEnum.cpp {{{1 +cat < StringToEnum.cpp /* -* \file StringAsEnum.cpp: +* \file StringToEnum.cpp: * \brief: output enum associated with string * @@ -45,5 +45,5 @@ #include "./EnumDefinitions.h" -int StringAsEnum(char* name){ +int StringToEnum(char* name){ END @@ -79,17 +79,17 @@ fi #}}} - #Add case to EnumAsString.cpp {{{ - cat <> EnumAsString.cpp + #Add case to EnumToString.cpp {{{ + cat <> EnumToString.cpp case $NAMEENUM : return "$NAME"; END #}}} - #Add case to StringAsEnum.cpp {{{ + #Add case to StringToEnum.cpp {{{ if [ $i -eq 1 ] then - cat <> StringAsEnum.cpp + cat <> StringToEnum.cpp if (strcmp(name,"$NAME")==0) return $NAMEENUM; END else - cat <> StringAsEnum.cpp + cat <> StringToEnum.cpp else if (strcmp(name,"$NAME")==0) return $NAMEENUM; END @@ -99,6 +99,6 @@ done -#Add footer of of EnumAsString.cpp{{{1 -cat <> EnumAsString.cpp +#Add footer of of EnumToString.cpp{{{1 +cat <> EnumToString.cpp default : return "unknown"; @@ -107,6 +107,6 @@ END #}}} -#Add footer of of StringAsEnum.cpp{{{1 -cat <> StringAsEnum.cpp +#Add footer of of StringToEnum.cpp{{{1 +cat <> StringToEnum.cpp else ISSMERROR("Enum %s not found",name); Index: /issm/trunk/src/c/Makefile.am =================================================================== --- /issm/trunk/src/c/Makefile.am (revision 5102) +++ /issm/trunk/src/c/Makefile.am (revision 5103) @@ -328,7 +328,7 @@ ./EnumDefinitions/EnumDefinitions.h\ ./EnumDefinitions/EnumDefinitions.cpp\ - ./EnumDefinitions/EnumAsString.cpp\ - ./EnumDefinitions/StringAsEnum.cpp\ - ./EnumDefinitions/EnumAsModelField.cpp\ + ./EnumDefinitions/EnumToString.cpp\ + ./EnumDefinitions/StringToEnum.cpp\ + ./EnumDefinitions/EnumToModelField.cpp\ ./modules/AddExternalResultx/AddExternalResultx.h\ ./modules/AddExternalResultx/AddExternalResultx.cpp\ @@ -860,7 +860,7 @@ ./EnumDefinitions/EnumDefinitions.h\ ./EnumDefinitions/EnumDefinitions.cpp\ - ./EnumDefinitions/EnumAsString.cpp\ - ./EnumDefinitions/StringAsEnum.cpp\ - ./EnumDefinitions/EnumAsModelField.cpp\ + ./EnumDefinitions/EnumToString.cpp\ + ./EnumDefinitions/StringToEnum.cpp\ + ./EnumDefinitions/EnumToModelField.cpp\ ./modules/AddExternalResultx/AddExternalResultx.h\ ./modules/AddExternalResultx/AddExternalResultx.cpp\ Index: /issm/trunk/src/c/io/FetchParams.cpp =================================================================== --- /issm/trunk/src/c/io/FetchParams.cpp (revision 5102) +++ /issm/trunk/src/c/io/FetchParams.cpp (revision 5103) @@ -53,5 +53,5 @@ /*Get i'th field: */ name=(char*)mxGetFieldNameByNumber(dataref,count); - enum_type=StringAsEnum(name); + enum_type=StringToEnum(name); pfield=mxGetFieldByNumber(dataref,0,count); ISSMASSERT(pfield); Index: /issm/trunk/src/c/modules/GetSolutionFromInputsx/GetSolutionFromInputsx.cpp =================================================================== --- /issm/trunk/src/c/modules/GetSolutionFromInputsx/GetSolutionFromInputsx.cpp (revision 5102) +++ /issm/trunk/src/c/modules/GetSolutionFromInputsx/GetSolutionFromInputsx.cpp (revision 5103) @@ -26,5 +26,5 @@ /*Get size of vector: */ gsize=nodes->NumberOfDofs(configuration_type); - if (gsize==0) ISSMERROR("Allocating a Vec of size 0 as gsize=0 for configuration: %s",EnumAsString(configuration_type)); + if (gsize==0) ISSMERROR("Allocating a Vec of size 0 as gsize=0 for configuration: %s",EnumToString(configuration_type)); /*Initialize solution: */ Index: /issm/trunk/src/c/modules/GetVectorFromInputsx/GetVectorFromInputsx.cpp =================================================================== --- /issm/trunk/src/c/modules/GetVectorFromInputsx/GetVectorFromInputsx.cpp (revision 5102) +++ /issm/trunk/src/c/modules/GetVectorFromInputsx/GetVectorFromInputsx.cpp (revision 5103) @@ -23,5 +23,5 @@ } } - else ISSMERROR("%s%s%s"," vector type: ",EnumAsString(TypeEnum)," not supported yet!"); + else ISSMERROR("%s%s%s"," vector type: ",EnumToString(TypeEnum)," not supported yet!"); VecAssemblyBegin(vector); Index: /issm/trunk/src/c/modules/InputUpdateFromDakotax/InputUpdateFromDakotax.cpp =================================================================== --- /issm/trunk/src/c/modules/InputUpdateFromDakotax/InputUpdateFromDakotax.cpp (revision 5102) +++ /issm/trunk/src/c/modules/InputUpdateFromDakotax/InputUpdateFromDakotax.cpp (revision 5103) @@ -54,5 +54,5 @@ /*Ok, variable is not distributed, just update inputs using the variable: */ - InputUpdateFromConstantx( elements,nodes, vertices,loads, materials, parameters, variables[i],StringAsEnum(descriptor)); + InputUpdateFromConstantx( elements,nodes, vertices,loads, materials, parameters, variables[i],StringToEnum(descriptor)); } @@ -69,5 +69,5 @@ /*Now, pick up the parameter corresponding to root: */ - if(!parameters->FindParam(¶meter_serial,NULL,StringAsEnum(root))){ + if(!parameters->FindParam(¶meter_serial,NULL,StringToEnum(root))){ ISSMERROR("%s%s"," could not find Qmu parameter: ",root); } @@ -89,5 +89,5 @@ PetscSynchronizedFlush(MPI_COMM_WORLD); } - PetscSynchronizedPrintf(MPI_COMM_WORLD," enum: %i\n",StringAsEnum(root)); + PetscSynchronizedPrintf(MPI_COMM_WORLD," enum: %i\n",StringToEnum(root)); PetscSynchronizedFlush(MPI_COMM_WORLD); #endif @@ -95,5 +95,5 @@ /*Update inputs using the parameter vector: */ - InputUpdateFromVectorx( elements,nodes, vertices,loads, materials, parameters, parameter, StringAsEnum(root), VertexEnum); + InputUpdateFromVectorx( elements,nodes, vertices,loads, materials, parameters, parameter, StringToEnum(root), VertexEnum); /*increment i to skip the distributed values just collected: */ Index: /issm/trunk/src/c/modules/ModelProcessorx/Control/CreateParametersControl.cpp =================================================================== --- /issm/trunk/src/c/modules/ModelProcessorx/Control/CreateParametersControl.cpp (revision 5102) +++ /issm/trunk/src/c/modules/ModelProcessorx/Control/CreateParametersControl.cpp (revision 5103) @@ -43,5 +43,5 @@ } else{ - ISSMERROR("Control for solution of type %s not supported yet",EnumAsString(solution_type)); + ISSMERROR("Control for solution of type %s not supported yet",EnumToString(solution_type)); } parameters->AddObject(new IntParam(NStepsEnum,iomodel->nsteps)); Index: /issm/trunk/src/c/modules/ModelProcessorx/CreateDataSets.cpp =================================================================== --- /issm/trunk/src/c/modules/ModelProcessorx/CreateDataSets.cpp (revision 5102) +++ /issm/trunk/src/c/modules/ModelProcessorx/CreateDataSets.cpp (revision 5103) @@ -106,5 +106,5 @@ break; default: - ISSMERROR("%s%s%s"," analysis_type: ",EnumAsString(analysis_type)," not supported yet!"); + ISSMERROR("%s%s%s"," analysis_type: ",EnumToString(analysis_type)," not supported yet!"); } Index: /issm/trunk/src/c/modules/ModelProcessorx/ModelProcessorx.cpp =================================================================== --- /issm/trunk/src/c/modules/ModelProcessorx/ModelProcessorx.cpp (revision 5102) +++ /issm/trunk/src/c/modules/ModelProcessorx/ModelProcessorx.cpp (revision 5103) @@ -41,5 +41,5 @@ analysis_type=analysis_type_list[i]; - _printf_(" create datasets for analysis %s\n",EnumAsString(analysis_type)); + _printf_(" create datasets for analysis %s\n",EnumToString(analysis_type)); CreateDataSets(&elements,&nodes,&vertices,&materials,&constraints,&loads,¶meters,iomodel,IOMODEL,solution_type,analysis_type,nummodels,i); } Index: /issm/trunk/src/c/modules/ModelProcessorx/Qmu/CreateParametersQmu.cpp =================================================================== --- /issm/trunk/src/c/modules/ModelProcessorx/Qmu/CreateParametersQmu.cpp (revision 5102) +++ /issm/trunk/src/c/modules/ModelProcessorx/Qmu/CreateParametersQmu.cpp (revision 5103) @@ -156,6 +156,6 @@ ){ - IoModelFetchData(&dakota_parameter,NULL,NULL,iomodel_handle,EnumAsModelField(StringAsEnum(descriptor))); - parameters->AddObject(new DoubleVecParam(StringAsEnum(descriptor),dakota_parameter,iomodel->numberofvertices)); + IoModelFetchData(&dakota_parameter,NULL,NULL,iomodel_handle,EnumToModelField(StringToEnum(descriptor))); + parameters->AddObject(new DoubleVecParam(StringToEnum(descriptor),dakota_parameter,iomodel->numberofvertices)); xfree((void**)&dakota_parameter); } Index: /issm/trunk/src/c/modules/OutputResultsx/MatlabWriteResults.cpp =================================================================== --- /issm/trunk/src/c/modules/OutputResultsx/MatlabWriteResults.cpp (revision 5102) +++ /issm/trunk/src/c/modules/OutputResultsx/MatlabWriteResults.cpp (revision 5103) @@ -75,5 +75,5 @@ for(i=0;i0){ - fnames[count]=EnumAsString(enums[i]); + fnames[count]=EnumToString(enums[i]); count++; } Index: /issm/trunk/src/c/modules/OutputResultsx/OutputResultsx.cpp =================================================================== --- /issm/trunk/src/c/modules/OutputResultsx/OutputResultsx.cpp (revision 5102) +++ /issm/trunk/src/c/modules/OutputResultsx/OutputResultsx.cpp (revision 5103) @@ -38,5 +38,5 @@ *therefore, we need to include the solutiontype into the filename: */ parameters->FindParam(&solutiontype,SolutionTypeEnum); - results->AddObject(new StringExternalResult(results->Size()+1,SolutionTypeEnum,EnumAsString(solutiontype),1,0)); + results->AddObject(new StringExternalResult(results->Size()+1,SolutionTypeEnum,EnumToString(solutiontype),1,0)); #endif Index: /issm/trunk/src/c/modules/Qmux/SpawnCoreParallel.cpp =================================================================== --- /issm/trunk/src/c/modules/Qmux/SpawnCoreParallel.cpp (revision 5102) +++ /issm/trunk/src/c/modules/Qmux/SpawnCoreParallel.cpp (revision 5103) @@ -64,5 +64,5 @@ /*Run the core solution sequence: */ - if(verbose)_printf_("%s%s%s\n","Starting ",EnumAsString(solution_type)," core:"); + if(verbose)_printf_("%s%s%s\n","Starting ",EnumToString(solution_type)," core:"); SolutionConfiguration(NULL,NULL,&solutioncore,solution_type); solutioncore(femmodel); Index: /issm/trunk/src/c/objects/Constraints/Spc.cpp =================================================================== --- /issm/trunk/src/c/objects/Constraints/Spc.cpp (revision 5102) +++ /issm/trunk/src/c/objects/Constraints/Spc.cpp (revision 5103) @@ -50,5 +50,5 @@ printf(" dof: %i\n",dof); printf(" value: %g\n",value); - printf(" analysis_type: %s\n",EnumAsString(analysis_type)); + printf(" analysis_type: %s\n",EnumToString(analysis_type)); return; } @@ -62,5 +62,5 @@ printf(" dof: %i\n",dof); printf(" value: %g\n",value); - printf(" analysis_type: %s\n",EnumAsString(analysis_type)); + printf(" analysis_type: %s\n",EnumToString(analysis_type)); return; } Index: /issm/trunk/src/c/objects/ElementResults/DoubleElementResult.cpp =================================================================== --- /issm/trunk/src/c/objects/ElementResults/DoubleElementResult.cpp (revision 5102) +++ /issm/trunk/src/c/objects/ElementResults/DoubleElementResult.cpp (revision 5103) @@ -49,5 +49,5 @@ printf("DoubleElementResult:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); printf(" value: %g\n",this->value); printf(" step: %i\n",this->step); Index: /issm/trunk/src/c/objects/ElementResults/PentaVertexElementResult.cpp =================================================================== --- /issm/trunk/src/c/objects/ElementResults/PentaVertexElementResult.cpp (revision 5102) +++ /issm/trunk/src/c/objects/ElementResults/PentaVertexElementResult.cpp (revision 5103) @@ -51,5 +51,5 @@ printf("PentaVertexElementResult:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); printf(" values: [%g %g %g %g %g %g]\n",this->values[0],this->values[1],this->values[2],this->values[3],this->values[4],this->values[5]); printf(" step: %i\n",this->step); Index: /issm/trunk/src/c/objects/ElementResults/TriaVertexElementResult.cpp =================================================================== --- /issm/trunk/src/c/objects/ElementResults/TriaVertexElementResult.cpp (revision 5102) +++ /issm/trunk/src/c/objects/ElementResults/TriaVertexElementResult.cpp (revision 5103) @@ -51,5 +51,5 @@ printf("TriaVertexElementResult:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); printf(" values: [%g %g %g]\n",this->values[0],this->values[1],this->values[2]); printf(" step: %i\n",this->step); Index: /issm/trunk/src/c/objects/Elements/Penta.cpp =================================================================== --- /issm/trunk/src/c/objects/Elements/Penta.cpp (revision 5102) +++ /issm/trunk/src/c/objects/Elements/Penta.cpp (revision 5103) @@ -404,5 +404,5 @@ } else{ - ISSMERROR("analysis %i (%s) not supported yet",analysis_type,EnumAsString(analysis_type)); + ISSMERROR("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type)); } } @@ -432,5 +432,5 @@ default: - ISSMERROR("type %i (%s) not implemented yet",type,EnumAsString(type)); + ISSMERROR("type %i (%s) not implemented yet",type,EnumToString(type)); } } @@ -781,5 +781,5 @@ CreateKMatrixMelting( Kgg); } - else ISSMERROR("analysis %i (%s) not supported yet",analysis_type,EnumAsString(analysis_type)); + else ISSMERROR("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type)); } @@ -833,5 +833,5 @@ CreatePVectorMelting( pg); } - else ISSMERROR("analysis %i (%s) not supported yet",analysis_type,EnumAsString(analysis_type)); + else ISSMERROR("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type)); } @@ -921,5 +921,5 @@ } else{ - ISSMERROR("analysis: %i (%s) not supported yet",analysis_type,EnumAsString(analysis_type)); + ISSMERROR("analysis: %i (%s) not supported yet",analysis_type,EnumToString(analysis_type)); } } @@ -971,5 +971,5 @@ GradjB(gradient); } - else ISSMERROR("control type %s not supported yet: ",EnumAsString(control_type)); + else ISSMERROR("control type %s not supported yet: ",EnumToString(control_type)); } /*}}}*/ @@ -988,6 +988,6 @@ new_inputs[i]=(Input*)this->inputs->GetInput(enums[2*i+0]); old_inputs[i]=(Input*)this->inputs->GetInput(enums[2*i+1]); - if(!new_inputs[i])ISSMERROR("%s%s"," could not find input with enum ",EnumAsString(enums[2*i+0])); - if(!old_inputs[i])ISSMERROR("%s%s"," could not find input with enum ",EnumAsString(enums[2*i+0])); + if(!new_inputs[i])ISSMERROR("%s%s"," could not find input with enum ",EnumToString(enums[2*i+0])); + if(!old_inputs[i])ISSMERROR("%s%s"," could not find input with enum ",EnumToString(enums[2*i+0])); } @@ -1069,5 +1069,5 @@ } else{ - ISSMERROR("control type %s not implemented yet",EnumAsString(control_type)); + ISSMERROR("control type %s not implemented yet",EnumToString(control_type)); } } @@ -1113,6 +1113,6 @@ original_input=(Input*)penta->matice->inputs->GetInput(enum_type); else - ISSMERROR("object %s not supported yet",EnumAsString(object_enum)); - if(!original_input) ISSMERROR("could not find input with enum %s",EnumAsString(enum_type)); + ISSMERROR("object %s not supported yet",EnumToString(object_enum)); + if(!original_input) ISSMERROR("could not find input with enum %s",EnumToString(enum_type)); /*If first time, initialize total_integrated_input*/ @@ -1123,5 +1123,5 @@ total_integrated_input=new DoubleInput(average_enum_type,0.0); else - ISSMERROR("object %s not supported yet",EnumAsString(original_input->Enum())); + ISSMERROR("object %s not supported yet",EnumToString(original_input->Enum())); } @@ -1171,5 +1171,5 @@ this->matice->inputs->AddInput((Input*)depth_averaged_input); else - ISSMERROR("object %s not supported yet",EnumAsString(object_enum)); + ISSMERROR("object %s not supported yet",EnumToString(object_enum)); } /*}}}*/ @@ -1189,5 +1189,5 @@ /*Make a copy of the original input: */ input=(Input*)this->inputs->GetInput(enum_type); - if(!input)ISSMERROR(" could not find old input with enum: %s",EnumAsString(enum_type)); + if(!input)ISSMERROR(" could not find old input with enum: %s",EnumToString(enum_type)); /*Scale: */ @@ -1209,5 +1209,5 @@ input=this->inputs->GetInput(enum_type); } - if (!input) ISSMERROR("Input %s not found in tria->inputs",EnumAsString(enum_type)); + if (!input) ISSMERROR("Input %s not found in tria->inputs",EnumToString(enum_type)); /*If we don't find it, no big deal, just don't do the transfer. Otherwise, build a new Result @@ -4820,5 +4820,5 @@ delete tria->matice; delete tria; } - else ISSMERROR("analysis %s not supported yet",EnumAsString(analysis_type)); + else ISSMERROR("analysis %s not supported yet",EnumToString(analysis_type)); @@ -4849,6 +4849,6 @@ original_input=(Input*)matice->inputs->GetInput(enum_type); else - ISSMERROR("object of type %s not supported yet",EnumAsString(object_type)); - if(!original_input) ISSMERROR("%s%s"," could not find input with enum:",EnumAsString(enum_type)); + ISSMERROR("object of type %s not supported yet",EnumToString(object_type)); + if(!original_input) ISSMERROR("%s%s"," could not find input with enum:",EnumToString(enum_type)); original_input->Extrude(); @@ -4872,5 +4872,5 @@ penta->matice->inputs->AddInput((Input*)copy); else - ISSMERROR("object of type %s not supported yet",EnumAsString(object_type)); + ISSMERROR("object of type %s not supported yet",EnumToString(object_type)); /*Stop if we have reached the surface*/ @@ -4967,5 +4967,5 @@ vz_input=inputs->GetInput(VzEnum); if (vz_input){ - if (vz_input->Enum()!=PentaVertexInputEnum) ISSMERROR("Cannot compute Vel as Vz is of type %s",EnumAsString(vz_input->Enum())); + if (vz_input->Enum()!=PentaVertexInputEnum) ISSMERROR("Cannot compute Vel as Vz is of type %s",EnumToString(vz_input->Enum())); vz_input->GetValuesPtr(&vz_ptr,&dummy); for(i=0;iEnum()!=PentaVertexInputEnum){ - ISSMERROR("Cannot compute Vel as Vz is of type %s",EnumAsString(vz_input->Enum())); + ISSMERROR("Cannot compute Vel as Vz is of type %s",EnumToString(vz_input->Enum())); } vz_input->GetValuesPtr(&vz_ptr,&dummy); @@ -5131,5 +5131,5 @@ if (vz_input){ if (vz_input->Enum()!=PentaVertexInputEnum){ - ISSMERROR("Cannot compute Vel as Vz is of type %s",EnumAsString(vz_input->Enum())); + ISSMERROR("Cannot compute Vel as Vz is of type %s",EnumToString(vz_input->Enum())); } vz_input->GetValuesPtr(&vz_ptr,&dummy); @@ -5214,5 +5214,5 @@ vx_input=inputs->GetInput(VxEnum); if (vx_input){ - if (vx_input->Enum()!=PentaVertexInputEnum) ISSMERROR("Cannot compute Vel as Vx is of type %s",EnumAsString(vx_input->Enum())); + if (vx_input->Enum()!=PentaVertexInputEnum) ISSMERROR("Cannot compute Vel as Vx is of type %s",EnumToString(vx_input->Enum())); vx_input->GetValuesPtr(&vx_ptr,&dummy); for(i=0;iGetInput(VyEnum); if (vy_input){ - if (vy_input->Enum()!=PentaVertexInputEnum) ISSMERROR("Cannot compute Vel as Vy is of type %s",EnumAsString(vy_input->Enum())); + if (vy_input->Enum()!=PentaVertexInputEnum) ISSMERROR("Cannot compute Vel as Vy is of type %s",EnumToString(vy_input->Enum())); vy_input->GetValuesPtr(&vy_ptr,&dummy); for(i=0;iinputs->GetInput(enums[2*i+0]); old_inputs[i]=(Input*)this->inputs->GetInput(enums[2*i+1]); - if(!new_inputs[i])ISSMERROR("%s%s"," could not find input with enum ",EnumAsString(enums[2*i+0])); - if(!old_inputs[i])ISSMERROR("%s%s"," could not find input with enum ",EnumAsString(enums[2*i+0])); + if(!new_inputs[i])ISSMERROR("%s%s"," could not find input with enum ",EnumToString(enums[2*i+0])); + if(!old_inputs[i])ISSMERROR("%s%s"," could not find input with enum ",EnumToString(enums[2*i+0])); } @@ -1317,6 +1317,6 @@ oldinput=(Input*)this->matice->inputs->GetInput(enum_type); else - ISSMERROR("object %s not supported yet",EnumAsString(object_enum)); - if(!oldinput)ISSMERROR("%s%s"," could not find old input with enum: ",EnumAsString(enum_type)); + ISSMERROR("object %s not supported yet",EnumToString(object_enum)); + if(!oldinput)ISSMERROR("%s%s"," could not find old input with enum: ",EnumToString(enum_type)); newinput=(Input*)oldinput->copy(); @@ -1330,5 +1330,5 @@ this->matice->inputs->AddInput((Input*)newinput); else - ISSMERROR("object %s not supported yet",EnumAsString(object_enum)); + ISSMERROR("object %s not supported yet",EnumToString(object_enum)); } @@ -1349,5 +1349,5 @@ /*Make a copy of the original input: */ input=(Input*)this->inputs->GetInput(enum_type); - if(!input)ISSMERROR(" could not find old input with enum: %s",EnumAsString(enum_type)); + if(!input)ISSMERROR(" could not find old input with enum: %s",EnumToString(enum_type)); /*Scale: */ @@ -1369,5 +1369,5 @@ input=this->inputs->GetInput(enum_type); } - if (!input) ISSMERROR("Input %s not found in tria->inputs",EnumAsString(enum_type)); + if (!input) ISSMERROR("Input %s not found in tria->inputs",EnumToString(enum_type)); /*If we don't find it, no big deal, just don't do the transfer. Otherwise, build a new Result @@ -5928,5 +5928,5 @@ if (vz_input){ if (vz_input->Enum()!=TriaVertexInputEnum){ - ISSMERROR("Cannot compute Vel as Vz is of type %s",EnumAsString(vz_input->Enum())); + ISSMERROR("Cannot compute Vel as Vz is of type %s",EnumToString(vz_input->Enum())); } vz_input->GetValuesPtr(&vz_ptr,&dummy); @@ -6007,5 +6007,5 @@ if (vz_input){ if (vz_input->Enum()!=TriaVertexInputEnum){ - ISSMERROR("Cannot compute Vel as Vz is of type %s",EnumAsString(vz_input->Enum())); + ISSMERROR("Cannot compute Vel as Vz is of type %s",EnumToString(vz_input->Enum())); } vz_input->GetValuesPtr(&vz_ptr,&dummy); Index: /issm/trunk/src/c/objects/ExternalResults/BoolExternalResult.cpp =================================================================== --- /issm/trunk/src/c/objects/ExternalResults/BoolExternalResult.cpp (revision 5102) +++ /issm/trunk/src/c/objects/ExternalResults/BoolExternalResult.cpp (revision 5103) @@ -53,5 +53,5 @@ printf("BoolExternalResult:\n"); printf(" id: %i\n",this->id); - printf(" enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); printf(" value: %s\n",this->value?"true":"false"); printf(" step: %i\n",this->step); @@ -156,5 +156,5 @@ /*First write enum: */ - name=EnumAsString(this->enum_type); + name=EnumToString(this->enum_type); length=(strlen(name)+1)*sizeof(char); fwrite(&length,sizeof(int),1,fid); @@ -179,5 +179,5 @@ /*FUNCTION BoolExternalResult::GetResultName{{{1*/ char* BoolExternalResult::GetResultName(void){ - return EnumAsString(this->enum_type); + return EnumToString(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/ExternalResults/DoubleExternalResult.cpp =================================================================== --- /issm/trunk/src/c/objects/ExternalResults/DoubleExternalResult.cpp (revision 5102) +++ /issm/trunk/src/c/objects/ExternalResults/DoubleExternalResult.cpp (revision 5103) @@ -53,5 +53,5 @@ printf("DoubleExternalResult:\n"); printf(" id: %i\n",this->id); - printf(" enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); printf(" value: %g\n",this->value); printf(" step: %i\n",this->step); @@ -155,5 +155,5 @@ /*First write enum: */ - name=EnumAsString(this->enum_type); + name=EnumToString(this->enum_type); length=(strlen(name)+1)*sizeof(char); fwrite(&length,sizeof(int),1,fid); @@ -175,5 +175,5 @@ /*FUNCTION DoubleExternalResult::GetResultName{{{1*/ char* DoubleExternalResult::GetResultName(void){ - return EnumAsString(this->enum_type); + return EnumToString(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/ExternalResults/DoubleMatExternalResult.cpp =================================================================== --- /issm/trunk/src/c/objects/ExternalResults/DoubleMatExternalResult.cpp (revision 5102) +++ /issm/trunk/src/c/objects/ExternalResults/DoubleMatExternalResult.cpp (revision 5103) @@ -58,5 +58,5 @@ printf("DoubleMatExternalResult:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); printf(" step: %i\n",this->step); printf(" time: %g\n",this->time); @@ -72,5 +72,5 @@ printf("DoubleMatExternalResult:\n"); printf(" id: %i\n",this->id); - printf(" enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); printf(" step: %i\n",this->step); printf(" time: %g\n",this->time); @@ -192,5 +192,5 @@ /*First write enum: */ - name=EnumAsString(this->enum_type); + name=EnumToString(this->enum_type); length=(strlen(name)+1)*sizeof(char); fwrite(&length,sizeof(int),1,fid); @@ -214,5 +214,5 @@ /*FUNCTION DoubleMatExternalResult::GetResultName{{{1*/ char* DoubleMatExternalResult::GetResultName(void){ - return EnumAsString(this->enum_type); + return EnumToString(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/ExternalResults/DoubleVecExternalResult.cpp =================================================================== --- /issm/trunk/src/c/objects/ExternalResults/DoubleVecExternalResult.cpp (revision 5102) +++ /issm/trunk/src/c/objects/ExternalResults/DoubleVecExternalResult.cpp (revision 5103) @@ -55,5 +55,5 @@ printf("DoubleVecExternalResult:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); printf(" vector size: %i\n",this->M); printf(" step: %i\n",this->step); @@ -69,5 +69,5 @@ printf("DoubleVecExternalResult:\n"); printf(" id: %i\n",this->id); - printf(" enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); printf(" vector size: %i\n",this->M); for(i=0;iM;i++){ @@ -180,5 +180,5 @@ /*First write enum: */ - name=EnumAsString(this->enum_type); + name=EnumToString(this->enum_type); length=(strlen(name)+1)*sizeof(char); fwrite(&length,sizeof(int),1,fid); @@ -200,5 +200,5 @@ /*FUNCTION DoubleVecExternalResult::GetResultName{{{1*/ char* DoubleVecExternalResult::GetResultName(void){ - return EnumAsString(this->enum_type); + return EnumToString(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/ExternalResults/IntExternalResult.cpp =================================================================== --- /issm/trunk/src/c/objects/ExternalResults/IntExternalResult.cpp (revision 5102) +++ /issm/trunk/src/c/objects/ExternalResults/IntExternalResult.cpp (revision 5103) @@ -53,5 +53,5 @@ printf("IntExternalResult:\n"); printf(" id: %i\n",this->id); - printf(" enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); printf(" value: %i\n",this->value); printf(" step: %i\n",this->step); @@ -156,5 +156,5 @@ /*First write enum: */ - name=EnumAsString(this->enum_type); + name=EnumToString(this->enum_type); length=(strlen(name)+1)*sizeof(char); fwrite(&length,sizeof(int),1,fid); @@ -179,5 +179,5 @@ /*FUNCTION IntExternalResult::GetResultName{{{1*/ char* IntExternalResult::GetResultName(void){ - return EnumAsString(this->enum_type); + return EnumToString(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/ExternalResults/PetscVecExternalResult.cpp =================================================================== --- /issm/trunk/src/c/objects/ExternalResults/PetscVecExternalResult.cpp (revision 5102) +++ /issm/trunk/src/c/objects/ExternalResults/PetscVecExternalResult.cpp (revision 5103) @@ -55,5 +55,5 @@ printf("PetscVecExternalResult:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); } @@ -65,5 +65,5 @@ printf("PetscVecExternalResult:\n"); printf(" id: %i\n",this->id); - printf(" enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); printf(" step: %i\n",this->step); printf(" time: %g\n",this->time); @@ -215,5 +215,5 @@ /*First write enum: */ - name=EnumAsString(this->enum_type); + name=EnumToString(this->enum_type); length=(strlen(name)+1)*sizeof(char); fwrite(&length,sizeof(int),1,fid); @@ -237,5 +237,5 @@ /*FUNCTION PetscVecExternalResult::GetResultName{{{1*/ char* PetscVecExternalResult::GetResultName(void){ - return EnumAsString(this->enum_type); + return EnumToString(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/ExternalResults/StringExternalResult.cpp =================================================================== --- /issm/trunk/src/c/objects/ExternalResults/StringExternalResult.cpp (revision 5102) +++ /issm/trunk/src/c/objects/ExternalResults/StringExternalResult.cpp (revision 5103) @@ -55,5 +55,5 @@ printf("StringExternalResult:\n"); printf(" id: %i\n",this->id); - printf(" enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); printf(" value: %s\n",this->value); printf(" step: %i\n",this->step); @@ -169,5 +169,5 @@ /*First write enum: */ - name=EnumAsString(this->enum_type); + name=EnumToString(this->enum_type); length=(strlen(name)+1)*sizeof(char); fwrite(&length,sizeof(int),1,fid); @@ -190,5 +190,5 @@ /*FUNCTION StringExternalResult::GetResultName{{{1*/ char* StringExternalResult::GetResultName(void){ - return EnumAsString(this->enum_type); + return EnumToString(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/FemModel.cpp =================================================================== --- /issm/trunk/src/c/objects/FemModel.cpp (revision 5102) +++ /issm/trunk/src/c/objects/FemModel.cpp (revision 5103) @@ -53,5 +53,5 @@ for(i=0;iSetCurrentConfiguration(analysis_type); @@ -118,7 +118,7 @@ printf(" number of fem models: %i\n",nummodels); printf(" analysis_type_list: \n"); - for(int i=0;ienum_type,EnumAsString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); printf(" value: %s\n",value?"true":"false"); } Index: /issm/trunk/src/c/objects/Inputs/DoubleInput.cpp =================================================================== --- /issm/trunk/src/c/objects/Inputs/DoubleInput.cpp (revision 5102) +++ /issm/trunk/src/c/objects/Inputs/DoubleInput.cpp (revision 5103) @@ -46,5 +46,5 @@ printf("DoubleInput:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); printf(" value: %g\n",this->value); } @@ -167,5 +167,5 @@ *pvalue=(int)value; #else - ISSMERROR("Double input of enum %i (%s) cannot return an integer",enum_type,EnumAsString(enum_type)); + ISSMERROR("Double input of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type)); #endif @@ -265,5 +265,5 @@ /*Check that input provided is a thickness*/ - if (thickness_input->EnumType()!=ThicknessEnum) ISSMERROR("Input provided is not a Thickness (enum_type is %s)",EnumAsString(thickness_input->EnumType())); + if (thickness_input->EnumType()!=ThicknessEnum) ISSMERROR("Input provided is not a Thickness (enum_type is %s)",EnumToString(thickness_input->EnumType())); /*vertically integrate depending on type:*/ Index: /issm/trunk/src/c/objects/Inputs/IntInput.cpp =================================================================== --- /issm/trunk/src/c/objects/Inputs/IntInput.cpp (revision 5102) +++ /issm/trunk/src/c/objects/Inputs/IntInput.cpp (revision 5103) @@ -41,5 +41,5 @@ printf("IntInput:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); printf(" value: %i\n",(int)this->value); } Index: /issm/trunk/src/c/objects/Inputs/PentaVertexInput.cpp =================================================================== --- /issm/trunk/src/c/objects/Inputs/PentaVertexInput.cpp (revision 5102) +++ /issm/trunk/src/c/objects/Inputs/PentaVertexInput.cpp (revision 5103) @@ -57,5 +57,5 @@ printf("PentaVertexInput:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); printf(" values: [%g %g %g %g %g %g]\n",this->values[0],this->values[1],this->values[2],this->values[3],this->values[4],this->values[5]); } @@ -501,5 +501,5 @@ /*Check that input provided is a thickness*/ - if (thickness_input->EnumType()!=ThicknessEnum) ISSMERROR("Input provided is not a Thickness (enum_type is %s)",EnumAsString(thickness_input->EnumType())); + if (thickness_input->EnumType()!=ThicknessEnum) ISSMERROR("Input provided is not a Thickness (enum_type is %s)",EnumToString(thickness_input->EnumType())); /*Get Thickness value pointer*/ @@ -536,5 +536,5 @@ /*Check that inputB is of the same type*/ - if (inputB->Enum()!=PentaVertexInputEnum) ISSMERROR("Operation not permitted because inputB is of type %s",EnumAsString(inputB->Enum())); + if (inputB->Enum()!=PentaVertexInputEnum) ISSMERROR("Operation not permitted because inputB is of type %s",EnumToString(inputB->Enum())); xinputB=(PentaVertexInput*)inputB; Index: /issm/trunk/src/c/objects/Inputs/TriaVertexInput.cpp =================================================================== --- /issm/trunk/src/c/objects/Inputs/TriaVertexInput.cpp (revision 5102) +++ /issm/trunk/src/c/objects/Inputs/TriaVertexInput.cpp (revision 5103) @@ -57,5 +57,5 @@ printf("TriaVertexInput:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); printf(" values: [%g %g %g]\n",this->values[0],this->values[1],this->values[2]); } Index: /issm/trunk/src/c/objects/Loads/Friction.cpp =================================================================== --- /issm/trunk/src/c/objects/Loads/Friction.cpp (revision 5102) +++ /issm/trunk/src/c/objects/Loads/Friction.cpp (revision 5103) @@ -49,5 +49,5 @@ void Friction::Echo(void){ printf("Friction:\n"); - printf(" analysis_type: %s\n",EnumAsString(analysis_type)); + printf(" analysis_type: %s\n",EnumToString(analysis_type)); printf(" element_type: %s\n",this->element_type); inputs->Echo(); Index: /issm/trunk/src/c/objects/Loads/Icefront.cpp =================================================================== --- /issm/trunk/src/c/objects/Loads/Icefront.cpp (revision 5102) +++ /issm/trunk/src/c/objects/Loads/Icefront.cpp (revision 5103) @@ -76,5 +76,5 @@ icefront_node_ids[3]=iomodel->nodecounter+(int)*(iomodel->pressureload+segment_width*i+3); } - else ISSMERROR("analysis_type %s not supported yet!",EnumAsString(in_analysis_type)); + else ISSMERROR("analysis_type %s not supported yet!",EnumToString(in_analysis_type)); if (icefront_type==QuadIceFrontEnum) num_nodes=4; @@ -117,5 +117,5 @@ printf("Icefront:\n"); printf(" id: %i\n",id); - printf(" analysis_type: %s\n",EnumAsString(analysis_type)); + printf(" analysis_type: %s\n",EnumToString(analysis_type)); hnodes->Echo(); helement->Echo(); @@ -132,5 +132,5 @@ printf("Icefront:\n"); printf(" id: %i\n",id); - printf(" analysis_type: %s\n",EnumAsString(analysis_type)); + printf(" analysis_type: %s\n",EnumToString(analysis_type)); hnodes->DeepEcho(); helement->DeepEcho(); @@ -319,5 +319,5 @@ } else{ - ISSMERROR("analysis %i (%s) not supported yet",analysis_type,EnumAsString(analysis_type)); + ISSMERROR("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type)); } } Index: /issm/trunk/src/c/objects/Loads/Numericalflux.cpp =================================================================== --- /issm/trunk/src/c/objects/Loads/Numericalflux.cpp (revision 5102) +++ /issm/trunk/src/c/objects/Loads/Numericalflux.cpp (revision 5103) @@ -142,5 +142,5 @@ printf("Numericalflux:\n"); printf(" id: %i\n",id); - printf(" analysis_type: %s\n",EnumAsString(analysis_type)); + printf(" analysis_type: %s\n",EnumToString(analysis_type)); hnodes->DeepEcho(); helement->DeepEcho(); Index: /issm/trunk/src/c/objects/Loads/Pengrid.cpp =================================================================== --- /issm/trunk/src/c/objects/Loads/Pengrid.cpp (revision 5102) +++ /issm/trunk/src/c/objects/Loads/Pengrid.cpp (revision 5103) @@ -91,5 +91,5 @@ printf("Pengrid:\n"); printf(" id: %i\n",id); - printf(" analysis_type: %s\n",EnumAsString(analysis_type)); + printf(" analysis_type: %s\n",EnumToString(analysis_type)); hnode->DeepEcho(); helement->DeepEcho(); @@ -301,5 +301,5 @@ } else{ - ISSMERROR("analysis %i (%s) not supported yet",analysis_type,EnumAsString(analysis_type)); + ISSMERROR("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type)); } @@ -327,5 +327,5 @@ } else{ - ISSMERROR("analysis %i (%s) not supported yet",analysis_type,EnumAsString(analysis_type)); + ISSMERROR("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type)); } @@ -462,5 +462,5 @@ } else{ - ISSMERROR("analysis: %s not supported yet",EnumAsString(analysis_type)); + ISSMERROR("analysis: %s not supported yet",EnumToString(analysis_type)); } Index: /issm/trunk/src/c/objects/Loads/Penpair.cpp =================================================================== --- /issm/trunk/src/c/objects/Loads/Penpair.cpp (revision 5102) +++ /issm/trunk/src/c/objects/Loads/Penpair.cpp (revision 5103) @@ -52,5 +52,5 @@ printf("Penpair:\n"); printf(" id: %i\n",id); - printf(" analysis_type: %s\n",EnumAsString(analysis_type)); + printf(" analysis_type: %s\n",EnumToString(analysis_type)); hnodes->Echo(); @@ -63,5 +63,5 @@ printf("Penpair:\n"); printf(" id: %i\n",id); - printf(" analysis_type: %s\n",EnumAsString(analysis_type)); + printf(" analysis_type: %s\n",EnumToString(analysis_type)); hnodes->DeepEcho(); @@ -216,5 +216,5 @@ } else{ - ISSMERROR("analysis %i (%s) not supported yet",analysis_type,EnumAsString(analysis_type)); + ISSMERROR("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type)); } } Index: /issm/trunk/src/c/objects/Loads/Riftfront.cpp =================================================================== --- /issm/trunk/src/c/objects/Loads/Riftfront.cpp (revision 5102) +++ /issm/trunk/src/c/objects/Loads/Riftfront.cpp (revision 5103) @@ -123,5 +123,5 @@ printf("Riftfront:\n"); printf(" id: %i\n",id); - printf(" analysis_type: %s\n",EnumAsString(analysis_type)); + printf(" analysis_type: %s\n",EnumToString(analysis_type)); hnodes->DeepEcho(); helements->DeepEcho(); Index: /issm/trunk/src/c/objects/Materials/Matice.cpp =================================================================== --- /issm/trunk/src/c/objects/Materials/Matice.cpp (revision 5102) +++ /issm/trunk/src/c/objects/Materials/Matice.cpp (revision 5103) @@ -578,7 +578,7 @@ return; - default: ISSMERROR("element %s not implemented yet",EnumAsString(element->Enum())); + default: ISSMERROR("element %s not implemented yet",EnumToString(element->Enum())); } - default: ISSMERROR("type %i (%s) not implemented yet",type,EnumAsString(type)); + default: ISSMERROR("type %i (%s) not implemented yet",type,EnumToString(type)); } } Index: /issm/trunk/src/c/objects/Node.cpp =================================================================== --- /issm/trunk/src/c/objects/Node.cpp (revision 5102) +++ /issm/trunk/src/c/objects/Node.cpp (revision 5103) @@ -171,5 +171,5 @@ printf(" id: %i\n",id); printf(" sid: %i\n",sid); - printf(" analysis_type: %s\n",EnumAsString(analysis_type)); + printf(" analysis_type: %s\n",EnumToString(analysis_type)); indexing.Echo(); printf(" hvertex: not displayed\n"); @@ -185,5 +185,5 @@ printf(" id: %i\n",id); printf(" sid: %i\n",sid); - printf(" analysis_type: %s\n",EnumAsString(analysis_type)); + printf(" analysis_type: %s\n",EnumToString(analysis_type)); indexing.DeepEcho(); printf("Vertex:\n"); Index: /issm/trunk/src/c/objects/Params/BoolParam.cpp =================================================================== --- /issm/trunk/src/c/objects/Params/BoolParam.cpp (revision 5102) +++ /issm/trunk/src/c/objects/Params/BoolParam.cpp (revision 5103) @@ -49,5 +49,5 @@ printf("BoolParam:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); printf(" value: %s\n",this->value?"true":"false"); } @@ -129,5 +129,5 @@ /*FUNCTION BoolParam::GetParameterName{{{1*/ char* BoolParam::GetParameterName(void){ - return EnumAsString(this->enum_type); + return EnumToString(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/Params/BoolParam.h =================================================================== --- /issm/trunk/src/c/objects/Params/BoolParam.h (revision 5102) +++ /issm/trunk/src/c/objects/Params/BoolParam.h (revision 5103) @@ -54,26 +54,26 @@ int EnumType(){return enum_type;} void GetParameterValue(bool* pbool){*pbool=value;} - void GetParameterValue(int* pinteger){ISSMERROR("Bool param of enum %i (%s) cannot return an integer",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double* pdouble){ISSMERROR("Bool param of enum %i (%s) cannot return a double",enum_type,EnumAsString(enum_type));} - void GetParameterValue(char** pstring){ISSMERROR("Bool param of enum %i (%s) cannot return a string",enum_type,EnumAsString(enum_type));} - void GetParameterValue(char*** pstringarray,int* pM){ISSMERROR("Bool param of enum %i (%s) cannot return a string arrayl",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM){ISSMERROR("Bool param of enum %i (%s) cannot return a double array",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM, int* pN){ISSMERROR("Bool param of enum %i (%s) cannot return a double array",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){ISSMERROR("Bool param of enum %i (%s) cannot return a matrix array",enum_type,EnumAsString(enum_type));} - void GetParameterValue(Vec* pvec){ISSMERROR("Bool param of enum %i (%s) cannot return a Vec",enum_type,EnumAsString(enum_type));} - void GetParameterValue(Mat* pmat){ISSMERROR("Bool param of enum %i (%s) cannot return a Mat",enum_type,EnumAsString(enum_type));} - void GetParameterValue(FILE** pfid){ISSMERROR("Bool param of enum %i (%s) cannot return a FILE",enum_type,EnumAsString(enum_type));} + void GetParameterValue(int* pinteger){ISSMERROR("Bool param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));} + void GetParameterValue(double* pdouble){ISSMERROR("Bool param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));} + void GetParameterValue(char** pstring){ISSMERROR("Bool param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));} + void GetParameterValue(char*** pstringarray,int* pM){ISSMERROR("Bool param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM){ISSMERROR("Bool param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM, int* pN){ISSMERROR("Bool param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));} + void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){ISSMERROR("Bool param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));} + void GetParameterValue(Vec* pvec){ISSMERROR("Bool param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));} + void GetParameterValue(Mat* pmat){ISSMERROR("Bool param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));} + void GetParameterValue(FILE** pfid){ISSMERROR("Bool param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));} void SetValue(bool boolean){this->value=boolean;} void SetValue(int integer){this->value=(bool)integer;} void SetValue(double scalar){this->value=(bool)scalar;} - void SetValue(char* string){ISSMERROR("Bool param of enum %i (%s) cannot hold a string",enum_type,EnumAsString(enum_type));} - void SetValue(char** stringarray,int M){ISSMERROR("Bool param of enum %i (%s) cannot hold a string array",enum_type,EnumAsString(enum_type));} - void SetValue(double* doublearray,int M){ISSMERROR("Bool param of enum %i (%s) cannot hold a double array",enum_type,EnumAsString(enum_type));} - void SetValue(double* pdoublearray,int M,int N){ISSMERROR("Bool param of enum %i (%s) cannot hold a double array",enum_type,EnumAsString(enum_type));} - void SetValue(Vec vec){ISSMERROR("Bool param of enum %i (%s) cannot hold a Vec",enum_type,EnumAsString(enum_type));} - void SetValue(Mat mat){ISSMERROR("Bool param of enum %i (%s) cannot hold a Mat",enum_type,EnumAsString(enum_type));} - void SetValue(FILE* fid){ISSMERROR("Bool param of enum %i (%s) cannot hold a FILE",enum_type,EnumAsString(enum_type));} - void SetValue(double** array, int M, int* mdim_array, int* ndim_array){ISSMERROR("Bool param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumAsString(enum_type));} + void SetValue(char* string){ISSMERROR("Bool param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));} + void SetValue(char** stringarray,int M){ISSMERROR("Bool param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));} + void SetValue(double* doublearray,int M){ISSMERROR("Bool param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));} + void SetValue(double* pdoublearray,int M,int N){ISSMERROR("Bool param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));} + void SetValue(Vec vec){ISSMERROR("Bool param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));} + void SetValue(Mat mat){ISSMERROR("Bool param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));} + void SetValue(FILE* fid){ISSMERROR("Bool param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));} + void SetValue(double** array, int M, int* mdim_array, int* ndim_array){ISSMERROR("Bool param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));} char* GetParameterName(void); Index: /issm/trunk/src/c/objects/Params/DoubleMatArrayParam.cpp =================================================================== --- /issm/trunk/src/c/objects/Params/DoubleMatArrayParam.cpp (revision 5102) +++ /issm/trunk/src/c/objects/Params/DoubleMatArrayParam.cpp (revision 5103) @@ -88,5 +88,5 @@ printf("DoubleMatArrayParam:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); printf(" array size: %i\n",this->M); printf(" array pointer: %p\n",this->array); @@ -102,5 +102,5 @@ printf("DoubleMatArrayParam:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); printf(" array size: %i\n",this->M); for(i=0;ienum_type); + return EnumToString(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/Params/DoubleMatArrayParam.h =================================================================== --- /issm/trunk/src/c/objects/Params/DoubleMatArrayParam.h (revision 5102) +++ /issm/trunk/src/c/objects/Params/DoubleMatArrayParam.h (revision 5103) @@ -56,26 +56,26 @@ /*Param vritual function definitions: {{{1*/ int EnumType(){return enum_type;} - void GetParameterValue(bool* pbool){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot return a bool",enum_type,EnumAsString(enum_type));} - void GetParameterValue(int* pinteger){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot return an integer",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double* pdouble){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot return a double",enum_type,EnumAsString(enum_type));} - void GetParameterValue(char** pstring){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot return a string",enum_type,EnumAsString(enum_type));} - void GetParameterValue(char*** pstringarray,int* pM){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot return a string arrayl",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot return a double array",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM, int* pN){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot return a double array",enum_type,EnumAsString(enum_type));} + void GetParameterValue(bool* pbool){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));} + void GetParameterValue(int* pinteger){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));} + void GetParameterValue(double* pdouble){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));} + void GetParameterValue(char** pstring){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));} + void GetParameterValue(char*** pstringarray,int* pM){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM, int* pN){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));} void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims); - void GetParameterValue(Vec* pvec){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot return a Vec",enum_type,EnumAsString(enum_type));} - void GetParameterValue(Mat* pmat){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot return a Mat",enum_type,EnumAsString(enum_type));} - void GetParameterValue(FILE** pfid){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot return a FILE",enum_type,EnumAsString(enum_type));} + void GetParameterValue(Vec* pvec){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));} + void GetParameterValue(Mat* pmat){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));} + void GetParameterValue(FILE** pfid){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));} - void SetValue(bool boolean){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot hold a boolean",enum_type,EnumAsString(enum_type));} - void SetValue(int integer){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot hold an integer",enum_type,EnumAsString(enum_type));} - void SetValue(double scalar){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot hold a scalar",enum_type,EnumAsString(enum_type));} - void SetValue(char* string){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot hold a string",enum_type,EnumAsString(enum_type));} - void SetValue(char** stringarray,int M){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot hold a string array",enum_type,EnumAsString(enum_type));} - void SetValue(double* doublearray,int M){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot hold a double vec array",enum_type,EnumAsString(enum_type));} - void SetValue(double* doublearray,int M,int N){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot hold a double mat array",enum_type,EnumAsString(enum_type));} - void SetValue(Vec vec){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot hold a Vec",enum_type,EnumAsString(enum_type));} - void SetValue(Mat mat){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot hold a Mat",enum_type,EnumAsString(enum_type));} - void SetValue(FILE* fid){ISSMERROR("Bool param of enum %i (%s) cannot hold a FILE",enum_type,EnumAsString(enum_type));} + void SetValue(bool boolean){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));} + void SetValue(int integer){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));} + void SetValue(double scalar){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));} + void SetValue(char* string){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));} + void SetValue(char** stringarray,int M){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));} + void SetValue(double* doublearray,int M){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot hold a double vec array",enum_type,EnumToString(enum_type));} + void SetValue(double* doublearray,int M,int N){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot hold a double mat array",enum_type,EnumToString(enum_type));} + void SetValue(Vec vec){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));} + void SetValue(Mat mat){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));} + void SetValue(FILE* fid){ISSMERROR("Bool param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));} void SetValue(double** array, int M, int* mdim_array, int* ndim_array); Index: /issm/trunk/src/c/objects/Params/DoubleMatParam.cpp =================================================================== --- /issm/trunk/src/c/objects/Params/DoubleMatParam.cpp (revision 5102) +++ /issm/trunk/src/c/objects/Params/DoubleMatParam.cpp (revision 5103) @@ -49,5 +49,5 @@ printf("DoubleMatParam:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); printf(" matrix size: %ix%i\n",this->M,this->N); @@ -60,5 +60,5 @@ printf("DoubleMatParam:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); printf(" matrix size: %ix%i\n",this->M,this->N); for(i=0;iM;i++){ @@ -170,5 +170,5 @@ /*FUNCTION DoubleMatParam::GetParameterName{{{1*/ char* DoubleMatParam::GetParameterName(void){ - return EnumAsString(this->enum_type); + return EnumToString(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/Params/DoubleMatParam.h =================================================================== --- /issm/trunk/src/c/objects/Params/DoubleMatParam.h (revision 5102) +++ /issm/trunk/src/c/objects/Params/DoubleMatParam.h (revision 5103) @@ -55,27 +55,27 @@ /*Param vritual function definitions: {{{1*/ int EnumType(){return enum_type;} - void GetParameterValue(bool* pbool){ISSMERROR("DoubleMat param of enum %i (%s) cannot return a bool",enum_type,EnumAsString(enum_type));} - void GetParameterValue(int* pinteger){ISSMERROR("DoubleMat param of enum %i (%s) cannot return an integer",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double* pdouble){ISSMERROR("DoubleMat param of enum %i (%s) cannot return a double",enum_type,EnumAsString(enum_type));} - void GetParameterValue(char** pstring){ISSMERROR("DoubleMat param of enum %i (%s) cannot return a string",enum_type,EnumAsString(enum_type));} - void GetParameterValue(char*** pstringarray,int* pM){ISSMERROR("DoubleMat param of enum %i (%s) cannot return a string arrayl",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM){ISSMERROR("DoubleMat param of enum %i (%s) cannot return a double array",enum_type,EnumAsString(enum_type));} + void GetParameterValue(bool* pbool){ISSMERROR("DoubleMat param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));} + void GetParameterValue(int* pinteger){ISSMERROR("DoubleMat param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));} + void GetParameterValue(double* pdouble){ISSMERROR("DoubleMat param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));} + void GetParameterValue(char** pstring){ISSMERROR("DoubleMat param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));} + void GetParameterValue(char*** pstringarray,int* pM){ISSMERROR("DoubleMat param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM){ISSMERROR("DoubleMat param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));} void GetParameterValue(double** pdoublearray,int* pM,int* pN); - void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){ISSMERROR("DoubleMat param of enum %i (%s) cannot return a matrix array",enum_type,EnumAsString(enum_type));} - void GetParameterValue(Vec* pvec){ISSMERROR("DoubleMat param of enum %i (%s) cannot return a Vec",enum_type,EnumAsString(enum_type));} - void GetParameterValue(Mat* pmat){ISSMERROR("DoubleMat param of enum %i (%s) cannot return a Mat",enum_type,EnumAsString(enum_type));} - void GetParameterValue(FILE** pfid){ISSMERROR("DoubleMat param of enum %i (%s) cannot return a FILE",enum_type,EnumAsString(enum_type));} + void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){ISSMERROR("DoubleMat param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));} + void GetParameterValue(Vec* pvec){ISSMERROR("DoubleMat param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));} + void GetParameterValue(Mat* pmat){ISSMERROR("DoubleMat param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));} + void GetParameterValue(FILE** pfid){ISSMERROR("DoubleMat param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));} - void SetValue(bool boolean){ISSMERROR("DoubleMat param of enum %i (%s) cannot hold a boolean",enum_type,EnumAsString(enum_type));} - void SetValue(int integer){ISSMERROR("DoubleMat param of enum %i (%s) cannot hold an integer",enum_type,EnumAsString(enum_type));} - void SetValue(double scalar){ISSMERROR("DoubleMat param of enum %i (%s) cannot hold a scalar",enum_type,EnumAsString(enum_type));} - void SetValue(char* string){ISSMERROR("DoubleMat param of enum %i (%s) cannot hold a string",enum_type,EnumAsString(enum_type));} - void SetValue(char** stringarray,int M){ISSMERROR("DoubleMat param of enum %i (%s) cannot hold a string array",enum_type,EnumAsString(enum_type));} - void SetValue(double* doublearray,int M){ISSMERROR("DoubleMat param of enum %i (%s) cannot hold a double vec array",enum_type,EnumAsString(enum_type));} + void SetValue(bool boolean){ISSMERROR("DoubleMat param of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));} + void SetValue(int integer){ISSMERROR("DoubleMat param of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));} + void SetValue(double scalar){ISSMERROR("DoubleMat param of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));} + void SetValue(char* string){ISSMERROR("DoubleMat param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));} + void SetValue(char** stringarray,int M){ISSMERROR("DoubleMat param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));} + void SetValue(double* doublearray,int M){ISSMERROR("DoubleMat param of enum %i (%s) cannot hold a double vec array",enum_type,EnumToString(enum_type));} void SetValue(double* doublearray,int M,int N); - void SetValue(Vec vec){ISSMERROR("DoubleMat param of enum %i (%s) cannot hold a Vec",enum_type,EnumAsString(enum_type));} - void SetValue(Mat mat){ISSMERROR("DoubleMat param of enum %i (%s) cannot hold a Mat",enum_type,EnumAsString(enum_type));} - void SetValue(FILE* fid){ISSMERROR("DoubleMat param of enum %i (%s) cannot hold a FILE",enum_type,EnumAsString(enum_type));} - void SetValue(double** array, int M, int* mdim_array, int* ndim_array){ISSMERROR("DoubleMat param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumAsString(enum_type));} + void SetValue(Vec vec){ISSMERROR("DoubleMat param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));} + void SetValue(Mat mat){ISSMERROR("DoubleMat param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));} + void SetValue(FILE* fid){ISSMERROR("DoubleMat param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));} + void SetValue(double** array, int M, int* mdim_array, int* ndim_array){ISSMERROR("DoubleMat param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));} char* GetParameterName(void); Index: /issm/trunk/src/c/objects/Params/DoubleParam.cpp =================================================================== --- /issm/trunk/src/c/objects/Params/DoubleParam.cpp (revision 5102) +++ /issm/trunk/src/c/objects/Params/DoubleParam.cpp (revision 5103) @@ -46,5 +46,5 @@ printf("DoubleParam:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); printf(" value: %g\n",this->value); } @@ -126,5 +126,5 @@ /*FUNCTION DoubleParam::GetParameterName{{{1*/ char* DoubleParam::GetParameterName(void){ - return EnumAsString(this->enum_type); + return EnumToString(this->enum_type); } /*}}}*/ @@ -134,5 +134,5 @@ *pinteger=(int)value; #else - ISSMERROR("Double param of enum %i (%s) cannot return an integer",enum_type,EnumAsString(enum_type)); + ISSMERROR("Double param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type)); #endif } @@ -147,5 +147,5 @@ #else - ISSMERROR("Double param of enum %i (%s) cannot return an bool",enum_type,EnumAsString(enum_type)); + ISSMERROR("Double param of enum %i (%s) cannot return an bool",enum_type,EnumToString(enum_type)); #endif } Index: /issm/trunk/src/c/objects/Params/DoubleParam.h =================================================================== --- /issm/trunk/src/c/objects/Params/DoubleParam.h (revision 5102) +++ /issm/trunk/src/c/objects/Params/DoubleParam.h (revision 5103) @@ -57,24 +57,24 @@ void GetParameterValue(int* pinteger); void GetParameterValue(double* pdouble){*pdouble=value;} - void GetParameterValue(char** pstring){ISSMERROR("Double param of enum %i (%s) cannot return a string",enum_type,EnumAsString(enum_type));} - void GetParameterValue(char*** pstringarray,int* pM){ISSMERROR("Double param of enum %i (%s) cannot return a string arrayl",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM){ISSMERROR("Double param of enum %i (%s) cannot return a double array",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM, int* pN){ISSMERROR("Double param of enum %i (%s) cannot return a double array",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){ISSMERROR("Double param of enum %i (%s) cannot return a matrix array",enum_type,EnumAsString(enum_type));} - void GetParameterValue(Vec* pvec){ISSMERROR("Double param of enum %i (%s) cannot return a Vec",enum_type,EnumAsString(enum_type));} - void GetParameterValue(Mat* pmat){ISSMERROR("Double param of enum %i (%s) cannot return a Mat",enum_type,EnumAsString(enum_type));} - void GetParameterValue(FILE** pfid){ISSMERROR("Double param of enum %i (%s) cannot return a FILE",enum_type,EnumAsString(enum_type));} + void GetParameterValue(char** pstring){ISSMERROR("Double param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));} + void GetParameterValue(char*** pstringarray,int* pM){ISSMERROR("Double param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM){ISSMERROR("Double param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM, int* pN){ISSMERROR("Double param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));} + void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){ISSMERROR("Double param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));} + void GetParameterValue(Vec* pvec){ISSMERROR("Double param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));} + void GetParameterValue(Mat* pmat){ISSMERROR("Double param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));} + void GetParameterValue(FILE** pfid){ISSMERROR("Double param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));} void SetValue(bool boolean){this->value=(double)boolean;} void SetValue(int integer){this->value=(double)integer;} void SetValue(double scalar){this->value=(double)scalar;} - void SetValue(char* string){ISSMERROR("Double param of enum %i (%s) cannot hold a string",enum_type,EnumAsString(enum_type));} - void SetValue(char** stringarray,int M){ISSMERROR("Double param of enum %i (%s) cannot hold a string array",enum_type,EnumAsString(enum_type));} - void SetValue(double* doublearray,int M){ISSMERROR("Double param of enum %i (%s) cannot hold a double array",enum_type,EnumAsString(enum_type));} - void SetValue(double* pdoublearray,int M,int N){ISSMERROR("Double param of enum %i (%s) cannot hold a double array",enum_type,EnumAsString(enum_type));} - void SetValue(Vec vec){ISSMERROR("Double param of enum %i (%s) cannot hold a Vec",enum_type,EnumAsString(enum_type));} - void SetValue(Mat mat){ISSMERROR("Double param of enum %i (%s) cannot hold a Mat",enum_type,EnumAsString(enum_type));} - void SetValue(FILE* fid){ISSMERROR("Double param of enum %i (%s) cannot hold a FILE",enum_type,EnumAsString(enum_type));} - void SetValue(double** array, int M, int* mdim_array, int* ndim_array){ISSMERROR("Double param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumAsString(enum_type));} + void SetValue(char* string){ISSMERROR("Double param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));} + void SetValue(char** stringarray,int M){ISSMERROR("Double param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));} + void SetValue(double* doublearray,int M){ISSMERROR("Double param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));} + void SetValue(double* pdoublearray,int M,int N){ISSMERROR("Double param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));} + void SetValue(Vec vec){ISSMERROR("Double param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));} + void SetValue(Mat mat){ISSMERROR("Double param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));} + void SetValue(FILE* fid){ISSMERROR("Double param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));} + void SetValue(double** array, int M, int* mdim_array, int* ndim_array){ISSMERROR("Double param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));} char* GetParameterName(void); Index: /issm/trunk/src/c/objects/Params/DoubleVecParam.cpp =================================================================== --- /issm/trunk/src/c/objects/Params/DoubleVecParam.cpp (revision 5102) +++ /issm/trunk/src/c/objects/Params/DoubleVecParam.cpp (revision 5103) @@ -48,5 +48,5 @@ printf("DoubleVecParam:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); printf(" vector size: %i\n",this->M); @@ -59,5 +59,5 @@ printf("DoubleVecParam:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); printf(" vector size: %i\n",this->M); for(i=0;iM;i++){ @@ -162,5 +162,5 @@ /*FUNCTION DoubleVecParam::GetParameterName{{{1*/ char* DoubleVecParam::GetParameterName(void){ - return EnumAsString(this->enum_type); + return EnumToString(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/Params/DoubleVecParam.h =================================================================== --- /issm/trunk/src/c/objects/Params/DoubleVecParam.h (revision 5102) +++ /issm/trunk/src/c/objects/Params/DoubleVecParam.h (revision 5103) @@ -54,27 +54,27 @@ /*Param virtual functions definitions: {{{1*/ int EnumType(){return enum_type;} - void GetParameterValue(bool* pbool){ISSMERROR("DoubleVec param of enum %i (%s) cannot return a bool",enum_type,EnumAsString(enum_type));} - void GetParameterValue(int* pinteger){ISSMERROR("DoubleVec param of enum %i (%s) cannot return an integer",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double* pdouble){ISSMERROR("DoubleVec param of enum %i (%s) cannot return a double",enum_type,EnumAsString(enum_type));} - void GetParameterValue(char** pstring){ISSMERROR("DoubleVec param of enum %i (%s) cannot return a string",enum_type,EnumAsString(enum_type));} - void GetParameterValue(char*** pstringarray,int* pM){ISSMERROR("DoubleVec param of enum %i (%s) cannot return a string arrayl",enum_type,EnumAsString(enum_type));} + void GetParameterValue(bool* pbool){ISSMERROR("DoubleVec param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));} + void GetParameterValue(int* pinteger){ISSMERROR("DoubleVec param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));} + void GetParameterValue(double* pdouble){ISSMERROR("DoubleVec param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));} + void GetParameterValue(char** pstring){ISSMERROR("DoubleVec param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));} + void GetParameterValue(char*** pstringarray,int* pM){ISSMERROR("DoubleVec param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));} void GetParameterValue(double** pdoublearray,int* pM); - void GetParameterValue(double** pdoublearray,int* pM, int* pN){ISSMERROR("DoubleVec param of enum %i (%s) cannot return a double array",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){ISSMERROR("DoubleVec param of enum %i (%s) cannot return a matrix array",enum_type,EnumAsString(enum_type));} - void GetParameterValue(Vec* pvec){ISSMERROR("DoubleVec param of enum %i (%s) cannot return a Vec",enum_type,EnumAsString(enum_type));} - void GetParameterValue(Mat* pmat){ISSMERROR("DoubleVec param of enum %i (%s) cannot return a Mat",enum_type,EnumAsString(enum_type));} - void GetParameterValue(FILE** pfid){ISSMERROR("DoubleVec param of enum %i (%s) cannot return a FILE",enum_type,EnumAsString(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM, int* pN){ISSMERROR("DoubleVec param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));} + void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){ISSMERROR("DoubleVec param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));} + void GetParameterValue(Vec* pvec){ISSMERROR("DoubleVec param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));} + void GetParameterValue(Mat* pmat){ISSMERROR("DoubleVec param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));} + void GetParameterValue(FILE** pfid){ISSMERROR("DoubleVec param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));} - void SetValue(bool boolean){ISSMERROR("DoubleVec param of enum %i (%s) cannot hold a boolean",enum_type,EnumAsString(enum_type));} - void SetValue(int integer){ISSMERROR("DoubleVec param of enum %i (%s) cannot hold an integer",enum_type,EnumAsString(enum_type));} - void SetValue(double scalar){ISSMERROR("DoubleVec param of enum %i (%s) cannot hold a scalar",enum_type,EnumAsString(enum_type));} - void SetValue(char* string){ISSMERROR("DoubleVec param of enum %i (%s) cannot hold a string",enum_type,EnumAsString(enum_type));} - void SetValue(char** stringarray,int M){ISSMERROR("DoubleVec param of enum %i (%s) cannot hold a string array",enum_type,EnumAsString(enum_type));} + void SetValue(bool boolean){ISSMERROR("DoubleVec param of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));} + void SetValue(int integer){ISSMERROR("DoubleVec param of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));} + void SetValue(double scalar){ISSMERROR("DoubleVec param of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));} + void SetValue(char* string){ISSMERROR("DoubleVec param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));} + void SetValue(char** stringarray,int M){ISSMERROR("DoubleVec param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));} void SetValue(double* doublearray,int M); - void SetValue(double* pdoublearray,int M,int N){ISSMERROR("DoubleVec param of enum %i (%s) cannot hold a double mat array",enum_type,EnumAsString(enum_type));} - void SetValue(Vec vec){ISSMERROR("DoubleVec param of enum %i (%s) cannot hold a Vec",enum_type,EnumAsString(enum_type));} - void SetValue(Mat mat){ISSMERROR("DoubleVec param of enum %i (%s) cannot hold a Mat",enum_type,EnumAsString(enum_type));} - void SetValue(FILE* fid){ISSMERROR("DoubleVec param of enum %i (%s) cannot hold a FILE",enum_type,EnumAsString(enum_type));} - void SetValue(double** array, int M, int* mdim_array, int* ndim_array){ISSMERROR("DoubleVec param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumAsString(enum_type));} + void SetValue(double* pdoublearray,int M,int N){ISSMERROR("DoubleVec param of enum %i (%s) cannot hold a double mat array",enum_type,EnumToString(enum_type));} + void SetValue(Vec vec){ISSMERROR("DoubleVec param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));} + void SetValue(Mat mat){ISSMERROR("DoubleVec param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));} + void SetValue(FILE* fid){ISSMERROR("DoubleVec param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));} + void SetValue(double** array, int M, int* mdim_array, int* ndim_array){ISSMERROR("DoubleVec param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));} char* GetParameterName(void); Index: /issm/trunk/src/c/objects/Params/FileParam.cpp =================================================================== --- /issm/trunk/src/c/objects/Params/FileParam.cpp (revision 5102) +++ /issm/trunk/src/c/objects/Params/FileParam.cpp (revision 5103) @@ -49,5 +49,5 @@ printf("FileParam:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); printf(" value: %p\n",this->value); } @@ -96,5 +96,5 @@ /*FUNCTION FileParam::GetParameterName{{{1*/ char* FileParam::GetParameterName(void){ - return EnumAsString(this->enum_type); + return EnumToString(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/Params/FileParam.h =================================================================== --- /issm/trunk/src/c/objects/Params/FileParam.h (revision 5102) +++ /issm/trunk/src/c/objects/Params/FileParam.h (revision 5103) @@ -52,27 +52,27 @@ /*Param vritual function definitions: {{{1*/ int EnumType(){return enum_type;} - void GetParameterValue(bool* pbool){ ISSMERROR("FileParam of enum %i (%s) cannot return a bool",enum_type,EnumAsString(enum_type));} - void GetParameterValue(int* pinteger){ISSMERROR("FileParam of enum %i (%s) cannot return a double",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double* pdouble){ISSMERROR("FileParam of enum %i (%s) cannot return a double",enum_type,EnumAsString(enum_type));} - void GetParameterValue(char** pstring){ISSMERROR("FileParam of enum %i (%s) cannot return a string",enum_type,EnumAsString(enum_type));} - void GetParameterValue(char*** pstringarray,int* pM){ISSMERROR("FileParam of enum %i (%s) cannot return a string arrayl",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM){ISSMERROR("FileParam of enum %i (%s) cannot return a double array",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM, int* pN){ISSMERROR("FileParam of enum %i (%s) cannot return a double array",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){ISSMERROR("File param of enum %i (%s) cannot return a matrix array",enum_type,EnumAsString(enum_type));} - void GetParameterValue(Vec* pvec){ISSMERROR("FileParam of enum %i (%s) cannot return a Vec",enum_type,EnumAsString(enum_type));} - void GetParameterValue(Mat* pmat){ISSMERROR("FileParam of enum %i (%s) cannot return a Mat",enum_type,EnumAsString(enum_type));} + void GetParameterValue(bool* pbool){ ISSMERROR("FileParam of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));} + void GetParameterValue(int* pinteger){ISSMERROR("FileParam of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));} + void GetParameterValue(double* pdouble){ISSMERROR("FileParam of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));} + void GetParameterValue(char** pstring){ISSMERROR("FileParam of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));} + void GetParameterValue(char*** pstringarray,int* pM){ISSMERROR("FileParam of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM){ISSMERROR("FileParam of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM, int* pN){ISSMERROR("FileParam of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));} + void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){ISSMERROR("File param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));} + void GetParameterValue(Vec* pvec){ISSMERROR("FileParam of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));} + void GetParameterValue(Mat* pmat){ISSMERROR("FileParam of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));} void GetParameterValue(FILE** pfid){*pfid=value;}; - void SetValue(bool boolean){ISSMERROR("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumAsString(enum_type));} - void SetValue(int integer){ISSMERROR("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumAsString(enum_type));} - void SetValue(double scalar){ISSMERROR("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumAsString(enum_type));} - void SetValue(char* string){ISSMERROR("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumAsString(enum_type));} - void SetValue(char** stringarray,int M){ISSMERROR("FileParam of enum %i (%s) cannot hold a string array",enum_type,EnumAsString(enum_type));} - void SetValue(double* doublearray,int M){ISSMERROR("FileParam of enum %i (%s) cannot hold a double array",enum_type,EnumAsString(enum_type));} - void SetValue(double* pdoublearray,int M,int N){ISSMERROR("FileParam of enum %i (%s) cannot hold a double array",enum_type,EnumAsString(enum_type));} - void SetValue(Vec vec){ISSMERROR("FileParam of enum %i (%s) cannot hold a Vec",enum_type,EnumAsString(enum_type));} - void SetValue(Mat mat){ISSMERROR("FileParam of enum %i (%s) cannot hold a Mat",enum_type,EnumAsString(enum_type));} - void SetValue(FILE* fid){ISSMERROR("File param of enum %i (%s) cannot hold a FILE",enum_type,EnumAsString(enum_type));} - void SetValue(double** array, int M, int* mdim_array, int* ndim_array){ISSMERROR("File param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumAsString(enum_type));} + void SetValue(bool boolean){ISSMERROR("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));} + void SetValue(int integer){ISSMERROR("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));} + void SetValue(double scalar){ISSMERROR("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));} + void SetValue(char* string){ISSMERROR("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));} + void SetValue(char** stringarray,int M){ISSMERROR("FileParam of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));} + void SetValue(double* doublearray,int M){ISSMERROR("FileParam of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));} + void SetValue(double* pdoublearray,int M,int N){ISSMERROR("FileParam of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));} + void SetValue(Vec vec){ISSMERROR("FileParam of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));} + void SetValue(Mat mat){ISSMERROR("FileParam of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));} + void SetValue(FILE* fid){ISSMERROR("File param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));} + void SetValue(double** array, int M, int* mdim_array, int* ndim_array){ISSMERROR("File param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));} char* GetParameterName(void); Index: /issm/trunk/src/c/objects/Params/IntParam.cpp =================================================================== --- /issm/trunk/src/c/objects/Params/IntParam.cpp (revision 5102) +++ /issm/trunk/src/c/objects/Params/IntParam.cpp (revision 5103) @@ -49,5 +49,5 @@ printf("IntParam:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); printf(" value: %i\n",this->value); } @@ -129,5 +129,5 @@ /*FUNCTION IntParam::GetParameterName{{{1*/ char* IntParam::GetParameterName(void){ - return EnumAsString(this->enum_type); + return EnumToString(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/Params/IntParam.h =================================================================== --- /issm/trunk/src/c/objects/Params/IntParam.h (revision 5102) +++ /issm/trunk/src/c/objects/Params/IntParam.h (revision 5103) @@ -53,27 +53,27 @@ /*Param vritual function definitions: {{{1*/ int EnumType(){return enum_type;} - void GetParameterValue(bool* pbool){ISSMERROR("Int param of enum %i (%s) cannot return a bool",enum_type,EnumAsString(enum_type));} + void GetParameterValue(bool* pbool){ISSMERROR("Int param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));} void GetParameterValue(int* pinteger){*pinteger=value;} - void GetParameterValue(double* pdouble){ISSMERROR("Int param of enum %i (%s) cannot return a double",enum_type,EnumAsString(enum_type));} - void GetParameterValue(char** pstring){ISSMERROR("Int param of enum %i (%s) cannot return a string",enum_type,EnumAsString(enum_type));} - void GetParameterValue(char*** pstringarray,int* pM){ISSMERROR("Int param of enum %i (%s) cannot return a string arrayl",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM){ISSMERROR("Int param of enum %i (%s) cannot return a double array",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM, int* pN){ISSMERROR("Int param of enum %i (%s) cannot return a double array",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){ISSMERROR("Int param of enum %i (%s) cannot return a matrix array",enum_type,EnumAsString(enum_type));} - void GetParameterValue(Vec* pvec){ISSMERROR("Int param of enum %i (%s) cannot return a Vec",enum_type,EnumAsString(enum_type));} - void GetParameterValue(Mat* pmat){ISSMERROR("Int param of enum %i (%s) cannot return a Mat",enum_type,EnumAsString(enum_type));} - void GetParameterValue(FILE** pfid){ISSMERROR("Int param of enum %i (%s) cannot return a FILE",enum_type,EnumAsString(enum_type));} + void GetParameterValue(double* pdouble){ISSMERROR("Int param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));} + void GetParameterValue(char** pstring){ISSMERROR("Int param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));} + void GetParameterValue(char*** pstringarray,int* pM){ISSMERROR("Int param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM){ISSMERROR("Int param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM, int* pN){ISSMERROR("Int param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));} + void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){ISSMERROR("Int param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));} + void GetParameterValue(Vec* pvec){ISSMERROR("Int param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));} + void GetParameterValue(Mat* pmat){ISSMERROR("Int param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));} + void GetParameterValue(FILE** pfid){ISSMERROR("Int param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));} void SetValue(bool boolean){this->value=(int)boolean;} void SetValue(int integer){this->value=integer;} void SetValue(double scalar){this->value=(int)scalar;} - void SetValue(char* string){ISSMERROR("Int param of enum %i (%s) cannot hold a string",enum_type,EnumAsString(enum_type));} - void SetValue(char** stringarray,int M){ISSMERROR("Int param of enum %i (%s) cannot hold a string array",enum_type,EnumAsString(enum_type));} - void SetValue(double* doublearray,int M){ISSMERROR("Int param of enum %i (%s) cannot hold a double array",enum_type,EnumAsString(enum_type));} - void SetValue(double* pdoublearray,int M,int N){ISSMERROR("Int param of enum %i (%s) cannot hold a double array",enum_type,EnumAsString(enum_type));} - void SetValue(Vec vec){ISSMERROR("Int param of enum %i (%s) cannot hold a Vec",enum_type,EnumAsString(enum_type));} - void SetValue(Mat mat){ISSMERROR("Int param of enum %i (%s) cannot hold a Mat",enum_type,EnumAsString(enum_type));} - void SetValue(FILE* fid){ISSMERROR("Int param of enum %i (%s) cannot hold a FILE",enum_type,EnumAsString(enum_type));} - void SetValue(double** array, int M, int* mdim_array, int* ndim_array){ISSMERROR("Int param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumAsString(enum_type));} + void SetValue(char* string){ISSMERROR("Int param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));} + void SetValue(char** stringarray,int M){ISSMERROR("Int param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));} + void SetValue(double* doublearray,int M){ISSMERROR("Int param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));} + void SetValue(double* pdoublearray,int M,int N){ISSMERROR("Int param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));} + void SetValue(Vec vec){ISSMERROR("Int param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));} + void SetValue(Mat mat){ISSMERROR("Int param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));} + void SetValue(FILE* fid){ISSMERROR("Int param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));} + void SetValue(double** array, int M, int* mdim_array, int* ndim_array){ISSMERROR("Int param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));} char* GetParameterName(void); Index: /issm/trunk/src/c/objects/Params/PetscMatParam.cpp =================================================================== --- /issm/trunk/src/c/objects/Params/PetscMatParam.cpp (revision 5102) +++ /issm/trunk/src/c/objects/Params/PetscMatParam.cpp (revision 5103) @@ -49,5 +49,5 @@ printf("PetscMatParam:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); } @@ -58,5 +58,5 @@ int i; printf("PetscMatParam:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); MatView(value,PETSC_VIEWER_STDOUT_WORLD); } @@ -200,5 +200,5 @@ /*FUNCTION PetscMatParam::GetParameterName{{{1*/ char* PetscMatParam::GetParameterName(void){ - return EnumAsString(this->enum_type); + return EnumToString(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/Params/PetscMatParam.h =================================================================== --- /issm/trunk/src/c/objects/Params/PetscMatParam.h (revision 5102) +++ /issm/trunk/src/c/objects/Params/PetscMatParam.h (revision 5103) @@ -54,27 +54,27 @@ /*Param vritual function definitions: {{{1*/ int EnumType(){return enum_type;} - void GetParameterValue(bool* pbool){ISSMERROR("PetscMat param of enum %i (%s) cannot return a bool",enum_type,EnumAsString(enum_type));} - void GetParameterValue(int* pinteger){ISSMERROR("PetscMat param of enum %i (%s) cannot return an integer",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double* pdouble){ISSMERROR("PetscMat param of enum %i (%s) cannot return a double",enum_type,EnumAsString(enum_type));} - void GetParameterValue(char** pstring){ISSMERROR("PetscMat param of enum %i (%s) cannot return a string",enum_type,EnumAsString(enum_type));} - void GetParameterValue(char*** pstringarray,int* pM){ISSMERROR("PetscMat param of enum %i (%s) cannot return a string arrayl",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM){ISSMERROR("PetscMat param of enum %i (%s) cannot return a double array",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM, int* pN){ISSMERROR("PetscMat param of enum %i (%s) cannot return a double array",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){ISSMERROR("PetscMat param of enum %i (%s) cannot return a matrix array",enum_type,EnumAsString(enum_type));} - void GetParameterValue(Vec* pvec){ISSMERROR("PetscMat param of enum %i (%s) cannot return a vec",enum_type,EnumAsString(enum_type));} + void GetParameterValue(bool* pbool){ISSMERROR("PetscMat param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));} + void GetParameterValue(int* pinteger){ISSMERROR("PetscMat param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));} + void GetParameterValue(double* pdouble){ISSMERROR("PetscMat param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));} + void GetParameterValue(char** pstring){ISSMERROR("PetscMat param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));} + void GetParameterValue(char*** pstringarray,int* pM){ISSMERROR("PetscMat param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM){ISSMERROR("PetscMat param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM, int* pN){ISSMERROR("PetscMat param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));} + void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){ISSMERROR("PetscMat param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));} + void GetParameterValue(Vec* pvec){ISSMERROR("PetscMat param of enum %i (%s) cannot return a vec",enum_type,EnumToString(enum_type));} void GetParameterValue(Mat* poutput); - void GetParameterValue(FILE** pfid){ISSMERROR("PetscMat param of enum %i (%s) cannot return a FILE",enum_type,EnumAsString(enum_type));} + void GetParameterValue(FILE** pfid){ISSMERROR("PetscMat param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));} - void SetValue(bool boolean){ISSMERROR("PetscMat param of enum %i (%s) cannot hold a boolean",enum_type,EnumAsString(enum_type));} - void SetValue(int integer){ISSMERROR("PetscMat param of enum %i (%s) cannot hold an integer",enum_type,EnumAsString(enum_type));} - void SetValue(double scalar){ISSMERROR("PetscMat param of enum %i (%s) cannot hold a scalar",enum_type,EnumAsString(enum_type));} - void SetValue(char* string){ISSMERROR("PetscMat param of enum %i (%s) cannot hold a string",enum_type,EnumAsString(enum_type));} - void SetValue(char** stringarray,int M){ISSMERROR("PetscMat param of enum %i (%s) cannot hold a string array",enum_type,EnumAsString(enum_type));} - void SetValue(double* doublearray,int M){ISSMERROR("PetscMat param of enum %i (%s) cannot hold a double array",enum_type,EnumAsString(enum_type));} - void SetValue(double* pdoublearray,int M,int N){ISSMERROR("PetscMat param of enum %i (%s) cannot hold a double array",enum_type,EnumAsString(enum_type));} - void SetValue(Vec vec){ISSMERROR("PetscMat param of enum %i (%s) cannot hold a Vec",enum_type,EnumAsString(enum_type));} + void SetValue(bool boolean){ISSMERROR("PetscMat param of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));} + void SetValue(int integer){ISSMERROR("PetscMat param of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));} + void SetValue(double scalar){ISSMERROR("PetscMat param of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));} + void SetValue(char* string){ISSMERROR("PetscMat param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));} + void SetValue(char** stringarray,int M){ISSMERROR("PetscMat param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));} + void SetValue(double* doublearray,int M){ISSMERROR("PetscMat param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));} + void SetValue(double* pdoublearray,int M,int N){ISSMERROR("PetscMat param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));} + void SetValue(Vec vec){ISSMERROR("PetscMat param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));} void SetValue(Mat mat); - void SetValue(FILE* fid){ISSMERROR("PetscMat param of enum %i (%s) cannot hold a FILE",enum_type,EnumAsString(enum_type));} - void SetValue(double** array, int M, int* mdim_array, int* ndim_array){ISSMERROR("PetscMat param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumAsString(enum_type));} + void SetValue(FILE* fid){ISSMERROR("PetscMat param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));} + void SetValue(double** array, int M, int* mdim_array, int* ndim_array){ISSMERROR("PetscMat param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));} char* GetParameterName(void); Index: /issm/trunk/src/c/objects/Params/PetscVecParam.cpp =================================================================== --- /issm/trunk/src/c/objects/Params/PetscVecParam.cpp (revision 5102) +++ /issm/trunk/src/c/objects/Params/PetscVecParam.cpp (revision 5103) @@ -50,5 +50,5 @@ printf("PetscVecParam:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); } @@ -59,5 +59,5 @@ int i; printf("PetscVecParam:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); VecView(value,PETSC_VIEWER_STDOUT_WORLD); } @@ -193,5 +193,5 @@ /*FUNCTION PetscVecParam::GetParameterName{{{1*/ char* PetscVecParam::GetParameterName(void){ - return EnumAsString(this->enum_type); + return EnumToString(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/Params/PetscVecParam.h =================================================================== --- /issm/trunk/src/c/objects/Params/PetscVecParam.h (revision 5102) +++ /issm/trunk/src/c/objects/Params/PetscVecParam.h (revision 5103) @@ -54,27 +54,27 @@ /*Param vritual function definitions: {{{1*/ int EnumType(){return enum_type;} - void GetParameterValue(bool* pbool){ISSMERROR("PetscVec param of enum %i (%s) cannot return a bool",enum_type,EnumAsString(enum_type));} - void GetParameterValue(int* pinteger){ISSMERROR("PetscVec param of enum %i (%s) cannot return an integer",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double* pdouble){ISSMERROR("PetscVec param of enum %i (%s) cannot return a double",enum_type,EnumAsString(enum_type));} - void GetParameterValue(char** pstring){ISSMERROR("PetscVec param of enum %i (%s) cannot return a string",enum_type,EnumAsString(enum_type));} - void GetParameterValue(char*** pstringarray,int* pM){ISSMERROR("PetscVec param of enum %i (%s) cannot return a string arrayl",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM){ISSMERROR("PetscVec param of enum %i (%s) cannot return a double array",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM, int* pN){ISSMERROR("PetscVec param of enum %i (%s) cannot return a double array",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){ISSMERROR("PetscVec param of enum %i (%s) cannot return a matrix array",enum_type,EnumAsString(enum_type));} - void GetParameterValue(Mat* pmat){ISSMERROR("PetscVec param of enum %i (%s) cannot return a Mat",enum_type,EnumAsString(enum_type));} + void GetParameterValue(bool* pbool){ISSMERROR("PetscVec param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));} + void GetParameterValue(int* pinteger){ISSMERROR("PetscVec param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));} + void GetParameterValue(double* pdouble){ISSMERROR("PetscVec param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));} + void GetParameterValue(char** pstring){ISSMERROR("PetscVec param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));} + void GetParameterValue(char*** pstringarray,int* pM){ISSMERROR("PetscVec param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM){ISSMERROR("PetscVec param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM, int* pN){ISSMERROR("PetscVec param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));} + void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){ISSMERROR("PetscVec param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));} + void GetParameterValue(Mat* pmat){ISSMERROR("PetscVec param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));} void GetParameterValue(Vec* poutput); - void GetParameterValue(FILE** pfid){ISSMERROR("PetscVec of enum %i (%s) cannot return a FILE",enum_type,EnumAsString(enum_type));} + void GetParameterValue(FILE** pfid){ISSMERROR("PetscVec of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));} - void SetValue(bool boolean){ISSMERROR("PetscVec of enum %i (%s) cannot hold a boolean",enum_type,EnumAsString(enum_type));} - void SetValue(int integer){ISSMERROR("PetscVec of enum %i (%s) cannot hold an integer",enum_type,EnumAsString(enum_type));} - void SetValue(double scalar){ISSMERROR("PetscVec of enum %i (%s) cannot hold a scalar",enum_type,EnumAsString(enum_type));} - void SetValue(char* string){ISSMERROR("PetscVec of enum %i (%s) cannot hold a string",enum_type,EnumAsString(enum_type));} - void SetValue(char** stringarray,int M){ISSMERROR("PetscVec of enum %i (%s) cannot hold a string array",enum_type,EnumAsString(enum_type));} - void SetValue(double* doublearray,int M){ISSMERROR("PetscVec of enum %i (%s) cannot hold a double array",enum_type,EnumAsString(enum_type));} - void SetValue(double* pdoublearray,int M,int N){ISSMERROR("PetscVec of enum %i (%s) cannot hold a double array",enum_type,EnumAsString(enum_type));} + void SetValue(bool boolean){ISSMERROR("PetscVec of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));} + void SetValue(int integer){ISSMERROR("PetscVec of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));} + void SetValue(double scalar){ISSMERROR("PetscVec of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));} + void SetValue(char* string){ISSMERROR("PetscVec of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));} + void SetValue(char** stringarray,int M){ISSMERROR("PetscVec of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));} + void SetValue(double* doublearray,int M){ISSMERROR("PetscVec of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));} + void SetValue(double* pdoublearray,int M,int N){ISSMERROR("PetscVec of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));} void SetValue(Vec vec); - void SetValue(Mat mat){ISSMERROR("PetscVec of enum %i (%s) cannot hold a Mat",enum_type,EnumAsString(enum_type));} - void SetValue(FILE* fid){ISSMERROR("PetscVec of enum %i (%s) cannot hold a FILE",enum_type,EnumAsString(enum_type));} - void SetValue(double** array, int M, int* mdim_array, int* ndim_array){ISSMERROR("PetscVec param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumAsString(enum_type));} + void SetValue(Mat mat){ISSMERROR("PetscVec of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));} + void SetValue(FILE* fid){ISSMERROR("PetscVec of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));} + void SetValue(double** array, int M, int* mdim_array, int* ndim_array){ISSMERROR("PetscVec param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));} char* GetParameterName(void); Index: /issm/trunk/src/c/objects/Params/StringArrayParam.cpp =================================================================== --- /issm/trunk/src/c/objects/Params/StringArrayParam.cpp (revision 5102) +++ /issm/trunk/src/c/objects/Params/StringArrayParam.cpp (revision 5103) @@ -73,5 +73,5 @@ printf("StringArrayParam:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); for(i=0;inumstrings;i++){ string=this->value[i]; @@ -222,5 +222,5 @@ /*FUNCTION StringArrayParam::GetParameterName{{{1*/ char* StringArrayParam::GetParameterName(void){ - return EnumAsString(this->enum_type); + return EnumToString(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/Params/StringArrayParam.h =================================================================== --- /issm/trunk/src/c/objects/Params/StringArrayParam.h (revision 5102) +++ /issm/trunk/src/c/objects/Params/StringArrayParam.h (revision 5103) @@ -56,27 +56,27 @@ /*Param vritual function definitions: {{{1*/ int EnumType(){return enum_type;} - void GetParameterValue(bool* pbool){ISSMERROR("StringArray param of enum %i (%s) cannot return a bool",enum_type,EnumAsString(enum_type));} - void GetParameterValue(int* pinteger){ISSMERROR("StringArray param of enum %i (%s) cannot return an integer",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double* pdouble){ISSMERROR("StringArray param of enum %i (%s) cannot return a double",enum_type,EnumAsString(enum_type));} - void GetParameterValue(char** pstring){ISSMERROR("StringArray param of enum %i (%s) cannot return a string",enum_type,EnumAsString(enum_type));} + void GetParameterValue(bool* pbool){ISSMERROR("StringArray param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));} + void GetParameterValue(int* pinteger){ISSMERROR("StringArray param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));} + void GetParameterValue(double* pdouble){ISSMERROR("StringArray param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));} + void GetParameterValue(char** pstring){ISSMERROR("StringArray param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));} void GetParameterValue(char*** pstringarray,int* pM); - void GetParameterValue(double** pdoublearray,int* pM){ISSMERROR("StringArray param of enum %i (%s) cannot return a double array",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM, int* pN){ISSMERROR("StringArray param of enum %i (%s) cannot return a double array",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){ISSMERROR("Vec param of enum %i (%s) cannot return a matrix array",enum_type,EnumAsString(enum_type));} - void GetParameterValue(Vec* pvec){ISSMERROR("StringArray param of enum %i (%s) cannot return a Vec",enum_type,EnumAsString(enum_type));} - void GetParameterValue(Mat* pmat){ISSMERROR("StringArray param of enum %i (%s) cannot return a Mat",enum_type,EnumAsString(enum_type));} - void GetParameterValue(FILE** pfid){ISSMERROR("StringArray param of enum %i (%s) cannot return a FILE",enum_type,EnumAsString(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM){ISSMERROR("StringArray param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM, int* pN){ISSMERROR("StringArray param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));} + void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){ISSMERROR("Vec param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));} + void GetParameterValue(Vec* pvec){ISSMERROR("StringArray param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));} + void GetParameterValue(Mat* pmat){ISSMERROR("StringArray param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));} + void GetParameterValue(FILE** pfid){ISSMERROR("StringArray param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));} - void SetValue(bool boolean){ISSMERROR("StringArray param of enum %i (%s) cannot hold a boolean",enum_type,EnumAsString(enum_type));} - void SetValue(int integer){ISSMERROR("StringArray param of enum %i (%s) cannot hold an integer",enum_type,EnumAsString(enum_type));} - void SetValue(double scalar){ISSMERROR("StringArray param of enum %i (%s) cannot hold a scalar",enum_type,EnumAsString(enum_type));} - void SetValue(char* string){ISSMERROR("StringArray param of enum %i (%s) cannot hold a string",enum_type,EnumAsString(enum_type));} + void SetValue(bool boolean){ISSMERROR("StringArray param of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));} + void SetValue(int integer){ISSMERROR("StringArray param of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));} + void SetValue(double scalar){ISSMERROR("StringArray param of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));} + void SetValue(char* string){ISSMERROR("StringArray param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));} void SetValue(char** stringarray,int M); - void SetValue(double* doublearray,int M){ISSMERROR("StringArray param of enum %i (%s) cannot hold a double array",enum_type,EnumAsString(enum_type));} - void SetValue(double* pdoublearray,int M,int N){ISSMERROR("StringArray param of enum %i (%s) cannot hold a double array",enum_type,EnumAsString(enum_type));} - void SetValue(Vec vec){ISSMERROR("StringArray param of enum %i (%s) cannot hold a Vec",enum_type,EnumAsString(enum_type));} - void SetValue(Mat mat){ISSMERROR("StringArray param of enum %i (%s) cannot hold a Mat",enum_type,EnumAsString(enum_type));} - void SetValue(FILE* fid){ISSMERROR("StringArray param of enum %i (%s) cannot hold a FILE",enum_type,EnumAsString(enum_type));} - void SetValue(double** array, int M, int* mdim_array, int* ndim_array){ISSMERROR("StringArray param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumAsString(enum_type));} + void SetValue(double* doublearray,int M){ISSMERROR("StringArray param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));} + void SetValue(double* pdoublearray,int M,int N){ISSMERROR("StringArray param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));} + void SetValue(Vec vec){ISSMERROR("StringArray param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));} + void SetValue(Mat mat){ISSMERROR("StringArray param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));} + void SetValue(FILE* fid){ISSMERROR("StringArray param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));} + void SetValue(double** array, int M, int* mdim_array, int* ndim_array){ISSMERROR("StringArray param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));} char* GetParameterName(void); Index: /issm/trunk/src/c/objects/Params/StringParam.cpp =================================================================== --- /issm/trunk/src/c/objects/Params/StringParam.cpp (revision 5102) +++ /issm/trunk/src/c/objects/Params/StringParam.cpp (revision 5103) @@ -50,5 +50,5 @@ void StringParam::DeepEcho(void){ printf("StringParam:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumAsString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); printf(" value: %s\n",this->value); } @@ -158,5 +158,5 @@ /*FUNCTION StringParam::GetParameterName{{{1*/ char* StringParam::GetParameterName(void){ - return EnumAsString(this->enum_type); + return EnumToString(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/Params/StringParam.h =================================================================== --- /issm/trunk/src/c/objects/Params/StringParam.h (revision 5102) +++ /issm/trunk/src/c/objects/Params/StringParam.h (revision 5103) @@ -54,27 +54,27 @@ /*Param vritual function definitions: {{{1*/ int EnumType(){return enum_type;} - void GetParameterValue(bool* pbool){ISSMERROR("String param of enum %i (%s) cannot return a bool",enum_type,EnumAsString(enum_type));} - void GetParameterValue(int* pinteger){ISSMERROR("String param of enum %i (%s) cannot return an integer",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double* pdouble){ISSMERROR("String param of enum %i (%s) cannot return a double",enum_type,EnumAsString(enum_type));} + void GetParameterValue(bool* pbool){ISSMERROR("String param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));} + void GetParameterValue(int* pinteger){ISSMERROR("String param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));} + void GetParameterValue(double* pdouble){ISSMERROR("String param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));} void GetParameterValue(char** pstring); - void GetParameterValue(char*** pstringarray,int* pM){ISSMERROR("String param of enum %i (%s) cannot return a string arrayl",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM){ISSMERROR("String param of enum %i (%s) cannot return a double array",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM, int* pN){ISSMERROR("String param of enum %i (%s) cannot return a double array",enum_type,EnumAsString(enum_type));} - void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){ISSMERROR("String param of enum %i (%s) cannot return a matrix array",enum_type,EnumAsString(enum_type));} - void GetParameterValue(Vec* pvec){ISSMERROR("String param of enum %i (%s) cannot return a Vec",enum_type,EnumAsString(enum_type));} - void GetParameterValue(Mat* pmat){ISSMERROR("String param of enum %i (%s) cannot return a Mat",enum_type,EnumAsString(enum_type));} - void GetParameterValue(FILE** pfid){ISSMERROR("Bool param of enum %i (%s) cannot return a FILE",enum_type,EnumAsString(enum_type));} + void GetParameterValue(char*** pstringarray,int* pM){ISSMERROR("String param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM){ISSMERROR("String param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM, int* pN){ISSMERROR("String param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));} + void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){ISSMERROR("String param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));} + void GetParameterValue(Vec* pvec){ISSMERROR("String param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));} + void GetParameterValue(Mat* pmat){ISSMERROR("String param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));} + void GetParameterValue(FILE** pfid){ISSMERROR("Bool param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));} - void SetValue(bool boolean){ISSMERROR("String param of enum %i (%s) cannot hold a boolean",enum_type,EnumAsString(enum_type));} - void SetValue(int integer){ISSMERROR("String param of enum %i (%s) cannot hold an integer",enum_type,EnumAsString(enum_type));} - void SetValue(double scalar){ISSMERROR("String param of enum %i (%s) cannot hold a scalar",enum_type,EnumAsString(enum_type));} + void SetValue(bool boolean){ISSMERROR("String param of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));} + void SetValue(int integer){ISSMERROR("String param of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));} + void SetValue(double scalar){ISSMERROR("String param of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));} void SetValue(char* string); - void SetValue(char** stringarray,int M){ISSMERROR("String param of enum %i (%s) cannot hold a string array",enum_type,EnumAsString(enum_type));} - void SetValue(double* doublearray,int M){ISSMERROR("String param of enum %i (%s) cannot hold a double array",enum_type,EnumAsString(enum_type));} - void SetValue(double* pdoublearray,int M,int N){ISSMERROR("String param of enum %i (%s) cannot hold a double array",enum_type,EnumAsString(enum_type));} - void SetValue(Vec vec){ISSMERROR("String param of enum %i (%s) cannot hold a Vec",enum_type,EnumAsString(enum_type));} - void SetValue(Mat mat){ISSMERROR("String param of enum %i (%s) cannot hold a Mat",enum_type,EnumAsString(enum_type));} - void SetValue(FILE* fid){ISSMERROR("String param of enum %i (%s) cannot hold a FILE",enum_type,EnumAsString(enum_type));} - void SetValue(double** array, int M, int* mdim_array, int* ndim_array){ISSMERROR("String param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumAsString(enum_type));} + void SetValue(char** stringarray,int M){ISSMERROR("String param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));} + void SetValue(double* doublearray,int M){ISSMERROR("String param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));} + void SetValue(double* pdoublearray,int M,int N){ISSMERROR("String param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));} + void SetValue(Vec vec){ISSMERROR("String param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));} + void SetValue(Mat mat){ISSMERROR("String param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));} + void SetValue(FILE* fid){ISSMERROR("String param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));} + void SetValue(double** array, int M, int* mdim_array, int* ndim_array){ISSMERROR("String param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));} char* GetParameterName(void); Index: /issm/trunk/src/c/shared/Dofs/DistributeNumDofs.cpp =================================================================== --- /issm/trunk/src/c/shared/Dofs/DistributeNumDofs.cpp (revision 5102) +++ /issm/trunk/src/c/shared/Dofs/DistributeNumDofs.cpp (revision 5103) @@ -43,5 +43,5 @@ numdofs=1; } - else ISSMERROR("analysis type: %i (%s) not implemented yet",analysis_type,EnumAsString(analysis_type)); + else ISSMERROR("analysis type: %i (%s) not implemented yet",analysis_type,EnumToString(analysis_type)); /*Assign output pointers:*/ Index: /issm/trunk/src/c/shared/Numerics/IsInputConverged.cpp =================================================================== --- /issm/trunk/src/c/shared/Numerics/IsInputConverged.cpp (revision 5102) +++ /issm/trunk/src/c/shared/Numerics/IsInputConverged.cpp (revision 5103) @@ -53,5 +53,5 @@ else eps=0; } - else ISSMERROR("%s%s%s"," convergence criterion ",EnumAsString(criterion_enum)," not supported yet!"); + else ISSMERROR("%s%s%s"," convergence criterion ",EnumToString(criterion_enum)," not supported yet!"); /*Assign output pointers:*/ Index: /issm/trunk/src/c/solutions/SolutionConfiguration.cpp =================================================================== --- /issm/trunk/src/c/solutions/SolutionConfiguration.cpp (revision 5102) +++ /issm/trunk/src/c/solutions/SolutionConfiguration.cpp (revision 5103) @@ -126,5 +126,5 @@ default: - ISSMERROR("%s%s%s"," solution type: ",EnumAsString(solutiontype)," not supported yet!"); + ISSMERROR("%s%s%s"," solution type: ",EnumToString(solutiontype)," not supported yet!"); break; } Index: /issm/trunk/src/c/solutions/control_core.cpp =================================================================== --- /issm/trunk/src/c/solutions/control_core.cpp (revision 5102) +++ /issm/trunk/src/c/solutions/control_core.cpp (revision 5103) @@ -106,5 +106,5 @@ InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,GradientEnum); femmodel->results->AddObject(new DoubleVecExternalResult(femmodel->results->Size()+1,JEnum,J,nsteps,1,0)); - femmodel->results->AddObject(new StringExternalResult(femmodel->results->Size()+1,ControlTypeEnum,EnumAsString(control_type),1,0)); + femmodel->results->AddObject(new StringExternalResult(femmodel->results->Size()+1,ControlTypeEnum,EnumToString(control_type),1,0)); cleanup_and_return: Index: /issm/trunk/src/c/solutions/controlrestart.cpp =================================================================== --- /issm/trunk/src/c/solutions/controlrestart.cpp (revision 5102) +++ /issm/trunk/src/c/solutions/controlrestart.cpp (revision 5103) @@ -19,5 +19,5 @@ InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,control_type); //the parameter itself! femmodel->results->AddObject(new DoubleVecExternalResult(femmodel->results->Size()+1,JEnum,J,nsteps,1,0)); - femmodel->results->AddObject(new StringExternalResult(femmodel->results->Size()+1,ControlTypeEnum,EnumAsString(control_type),1,0)); + femmodel->results->AddObject(new StringExternalResult(femmodel->results->Size()+1,ControlTypeEnum,EnumToString(control_type),1,0)); /*write to disk: */ Index: /issm/trunk/src/c/solutions/issm.cpp =================================================================== --- /issm/trunk/src/c/solutions/issm.cpp (revision 5102) +++ /issm/trunk/src/c/solutions/issm.cpp (revision 5103) @@ -50,5 +50,5 @@ _printf_("recover solution and file names:\n"); - solution_type=StringAsEnum(argv[1]); + solution_type=StringToEnum(argv[1]); inputfilename=argv[3]; outputfilename=argv[4]; Index: /issm/trunk/src/m/classes/public/loadresultsfromdisk.m =================================================================== --- /issm/trunk/src/m/classes/public/loadresultsfromdisk.m (revision 5102) +++ /issm/trunk/src/m/classes/public/loadresultsfromdisk.m (revision 5103) @@ -25,5 +25,5 @@ md.analysis_type=structure(1).SolutionType; if isscalar(md.sub_analysis_type), - md.sub_analysis_type=EnumAsString(md.sub_analysis_type); + md.sub_analysis_type=EnumToString(md.sub_analysis_type); end @@ -38,6 +38,6 @@ else - md.analysis_type =EnumAsString(md.analysis_type); - md.sub_analysis_type=EnumAsString(md.sub_analysis_type); + md.analysis_type =EnumToString(md.analysis_type); + md.sub_analysis_type=EnumToString(md.sub_analysis_type); md=postqmu(md); cd .. Index: /issm/trunk/src/m/classes/public/process_solve_options.m =================================================================== --- /issm/trunk/src/m/classes/public/process_solve_options.m (revision 5102) +++ /issm/trunk/src/m/classes/public/process_solve_options.m (revision 5103) @@ -27,5 +27,5 @@ SteadystateSolutionEnum,ParametersSolutionEnum,Transient2DSolutionEnum,Transient3DSolutionEnum... BalancedthicknessSolutionEnum,BalancedvelocitiesSolutionEnum,BedSlopeSolutionEnum,SurfaceSlopeSolutionEnum]), - error(['process_solve_options error message: analysis_type ' EnumAsString(analysis_type) ' not supported yet!']); + error(['process_solve_options error message: analysis_type ' EnumToString(analysis_type) ' not supported yet!']); end if ~ismember(sub_analysis_type,[SteadyAnalysisEnum,NoneAnalysisEnum,HorizAnalysisEnum,GradientAnalysisEnum,InverseAnalysisEnum,VertAnalysisEnum,TransientAnalysisEnum]), Index: /issm/trunk/src/m/classes/public/queue/ClusterScript.m =================================================================== --- /issm/trunk/src/m/classes/public/queue/ClusterScript.m (revision 5102) +++ /issm/trunk/src/m/classes/public/queue/ClusterScript.m (revision 5103) @@ -20,5 +20,5 @@ fprintf(fid,'ulimit -s unlimited\n'); fprintf(fid,'ulimit -c 0\n'); - fprintf(fid,'/opt/mpich/gm/intel10.1/bin/mpirun -np %i %s/issm.exe %s %s %s.bin %s.outbin %s.lock',np,codepath,EnumAsString(analysis_type),executionpath,name,name,name); + fprintf(fid,'/opt/mpich/gm/intel10.1/bin/mpirun -np %i %s/issm.exe %s %s %s.bin %s.outbin %s.lock',np,codepath,EnumToString(analysis_type),executionpath,name,name,name); % }}} @@ -28,8 +28,8 @@ fprintf(fid,'rm -rf %s/%s.lock\n',executionpath,name); if mem_debug==0, - fprintf(fid,'mpirun -np %i %s/issm.exe %s %s %s.bin %s.outbin %s.lock 2> %s.errlog >%s.outlog & ',np,codepath,EnumAsString(analysis_type),executionpath,name,name,name,name,name); + fprintf(fid,'mpirun -np %i %s/issm.exe %s %s %s.bin %s.outbin %s.lock 2> %s.errlog >%s.outlog & ',np,codepath,EnumToString(analysis_type),executionpath,name,name,name,name,name); else - %fprintf(fid,'LD_PRELOAD=%s mpirun -np %i %s --leak-check=full --gen-suppressions=all --suppressions=%s %s/issm.exe %s %s %s.bin %s.outbin %s.lock 2> %s.errlog >%s.outlog & ',[ISSM_DIR '/externalpackages/valgrind/install/lib/libmpidebug.so'],np,[ISSM_DIR '/externalpackages/valgrind/install/bin/valgrind'],[ISSM_DIR '/externalpackages/valgrind/issm.supp'], codepath,EnumAsString(analysis_type),executionpath,name,name,name,name,name); - fprintf(fid,'LD_PRELOAD=%s mpirun -np %i %s --leak-check=full --suppressions=%s %s/issm.exe %s %s %s.bin %s.outbin %s.lock 2> %s.errlog >%s.outlog & ',[ISSM_DIR '/externalpackages/valgrind/install/lib/libmpidebug.so'],np,[ISSM_DIR '/externalpackages/valgrind/install/bin/valgrind'],[ISSM_DIR '/externalpackages/valgrind/issm.supp'], codepath,EnumAsString(analysis_type),executionpath,name,name,name,name,name); + %fprintf(fid,'LD_PRELOAD=%s mpirun -np %i %s --leak-check=full --gen-suppressions=all --suppressions=%s %s/issm.exe %s %s %s.bin %s.outbin %s.lock 2> %s.errlog >%s.outlog & ',[ISSM_DIR '/externalpackages/valgrind/install/lib/libmpidebug.so'],np,[ISSM_DIR '/externalpackages/valgrind/install/bin/valgrind'],[ISSM_DIR '/externalpackages/valgrind/issm.supp'], codepath,EnumToString(analysis_type),executionpath,name,name,name,name,name); + fprintf(fid,'LD_PRELOAD=%s mpirun -np %i %s --leak-check=full --suppressions=%s %s/issm.exe %s %s %s.bin %s.outbin %s.lock 2> %s.errlog >%s.outlog & ',[ISSM_DIR '/externalpackages/valgrind/install/lib/libmpidebug.so'],np,[ISSM_DIR '/externalpackages/valgrind/install/bin/valgrind'],[ISSM_DIR '/externalpackages/valgrind/issm.supp'], codepath,EnumToString(analysis_type),executionpath,name,name,name,name,name); end @@ -49,5 +49,5 @@ fprintf(fid,'cd $PBS_O_WORKDIR\n'); fprintf(fid,'export OMP_NUM_THREADS=1\n'); - fprintf(fid,'dplace -s1 -c0-%i mpirun -np %i %s/issm.exe %s %s %s.bin %s.outbin %s.lock',np-1,np,codepath,EnumAsString(analysis_type),executionpath,name,name,name); + fprintf(fid,'dplace -s1 -c0-%i mpirun -np %i %s/issm.exe %s %s %s.bin %s.outbin %s.lock',np-1,np,codepath,EnumToString(analysis_type),executionpath,name,name,name); % }}} @@ -73,5 +73,5 @@ fprintf(fid,'cd $PBS_O_WORKDIR\n\n'); - fprintf(fid,'mpiexec -verbose -np %i %s/%s.exe $PBS_O_WORKDIR %s.bin %s.outbin %s.lock',np,codepath,EnumAsString(analysis_type),name,name,name); + fprintf(fid,'mpiexec -verbose -np %i %s/%s.exe $PBS_O_WORKDIR %s.bin %s.outbin %s.lock',np,codepath,EnumToString(analysis_type),name,name,name); % }}} Index: /issm/trunk/src/m/classes/public/queue/old/BuildQueueingScriptGeneric.m =================================================================== --- /issm/trunk/src/m/classes/public/queue/old/BuildQueueingScriptGeneric.m (revision 5102) +++ /issm/trunk/src/m/classes/public/queue/old/BuildQueueingScriptGeneric.m (revision 5103) @@ -19,7 +19,7 @@ if md.mem_debug==0, -fprintf(fid,'mpirun -np %i %s/%s.exe %s %s.bin %s.outbin %s.lock 2> %s.errlog >%s.outlog & ',md.np,codepath,EnumAsString(md.analysis_type),executionpath,md.name,md.name,md.name,md.name,md.name); +fprintf(fid,'mpirun -np %i %s/%s.exe %s %s.bin %s.outbin %s.lock 2> %s.errlog >%s.outlog & ',md.np,codepath,EnumToString(md.analysis_type),executionpath,md.name,md.name,md.name,md.name,md.name); else -fprintf(fid,'LD_PRELOAD=%s mpirun -np %i %s --leak-check=full %s/%s.exe %s %s.bin %s.outbin %s.lock 2> %s.errlog >%s.outlog & ',[ISSM_DIR '/externalpackages/valgrind/install/lib/libmpidebug.so'],md.np,[ISSM_DIR '/externalpackages/valgrind/install/bin/valgrind'],codepath,EnumAsString(md.analysis_type),executionpath,md.name,md.name,md.name,md.name,md.name); +fprintf(fid,'LD_PRELOAD=%s mpirun -np %i %s --leak-check=full %s/%s.exe %s %s.bin %s.outbin %s.lock 2> %s.errlog >%s.outlog & ',[ISSM_DIR '/externalpackages/valgrind/install/lib/libmpidebug.so'],md.np,[ISSM_DIR '/externalpackages/valgrind/install/bin/valgrind'],codepath,EnumToString(md.analysis_type),executionpath,md.name,md.name,md.name,md.name,md.name); end Index: /issm/trunk/src/m/classes/public/queue/old/BuildQueueingScriptcosmos.m =================================================================== --- /issm/trunk/src/m/classes/public/queue/old/BuildQueueingScriptcosmos.m (revision 5102) +++ /issm/trunk/src/m/classes/public/queue/old/BuildQueueingScriptcosmos.m (revision 5103) @@ -17,5 +17,5 @@ fprintf(fid,'ulimit -s unlimited\n'); fprintf(fid,'ulimit -c 0\n'); -fprintf(fid,'/opt/mpich/gm/intel10.1/bin/mpirun -np %i %s/%s.exe %s %s.bin %s.outbin %s.lock',md.np,codepath,EnumAsString(md.analysis_type),executionpath,md.name,md.name,md.name); +fprintf(fid,'/opt/mpich/gm/intel10.1/bin/mpirun -np %i %s/%s.exe %s %s.bin %s.outbin %s.lock',md.np,codepath,EnumToString(md.analysis_type),executionpath,md.name,md.name,md.name); Index: /issm/trunk/src/m/classes/public/queue/old/BuildQueueingScriptgemini.m =================================================================== --- /issm/trunk/src/m/classes/public/queue/old/BuildQueueingScriptgemini.m (revision 5102) +++ /issm/trunk/src/m/classes/public/queue/old/BuildQueueingScriptgemini.m (revision 5103) @@ -18,5 +18,5 @@ fprintf(fid,'cd $PBS_O_WORKDIR\n'); fprintf(fid,'export OMP_NUM_THREADS=1\n'); -fprintf(fid,'dplace -s1 -c0-%i mpirun -np %i %s/%s.exe %s %s.bin %s.outbin %s.lock',md.np-1,md.np,codepath,EnumAsString(md.analysis_type),executionpath,md.name,md.name,md.name); +fprintf(fid,'dplace -s1 -c0-%i mpirun -np %i %s/%s.exe %s %s.bin %s.outbin %s.lock',md.np-1,md.np,codepath,EnumToString(md.analysis_type),executionpath,md.name,md.name,md.name); fclose(fid); Index: /issm/trunk/src/m/classes/public/queue/old/BuildQueueingScriptgreenplanet.m =================================================================== --- /issm/trunk/src/m/classes/public/queue/old/BuildQueueingScriptgreenplanet.m (revision 5102) +++ /issm/trunk/src/m/classes/public/queue/old/BuildQueueingScriptgreenplanet.m (revision 5103) @@ -17,5 +17,5 @@ fprintf(fid,'cd $PBS_O_WORKDIR\n'); -fprintf(fid,'mpirun -machinefile $PBS_NODEFILE -np %i %s/%s.exe %s %s.bin %s.outbin %s.lock > %s.outlog',md.np,codepath,EnumAsString(md.analysis_type),executionpath,md.name,md.name,md.name,md.name); +fprintf(fid,'mpirun -machinefile $PBS_NODEFILE -np %i %s/%s.exe %s %s.bin %s.outbin %s.lock > %s.outlog',md.np,codepath,EnumToString(md.analysis_type),executionpath,md.name,md.name,md.name,md.name); fclose(fid); Index: /issm/trunk/src/m/classes/public/queue/old/BuildQueueingScriptpfe.m =================================================================== --- /issm/trunk/src/m/classes/public/queue/old/BuildQueueingScriptpfe.m (revision 5102) +++ /issm/trunk/src/m/classes/public/queue/old/BuildQueueingScriptpfe.m (revision 5103) @@ -45,5 +45,5 @@ fprintf(fid,'cd $PBS_O_WORKDIR\n\n'); -fprintf(fid,'mpiexec -verbose -np %i %s/%s.exe $PBS_O_WORKDIR %s.bin %s.outbin %s.lock',md.np,codepath,EnumAsString(md.analysis_type),md.name,md.name,md.name); +fprintf(fid,'mpiexec -verbose -np %i %s/%s.exe $PBS_O_WORKDIR %s.bin %s.outbin %s.lock',md.np,codepath,EnumToString(md.analysis_type),md.name,md.name,md.name); fclose(fid); Index: /issm/trunk/src/m/classes/public/solve.m =================================================================== --- /issm/trunk/src/m/classes/public/solve.m (revision 5102) +++ /issm/trunk/src/m/classes/public/solve.m (revision 5103) @@ -69,4 +69,4 @@ %convert analysis type to string finally -md.analysis_type=EnumAsString(options.analysis_type); -md.sub_analysis_type=EnumAsString(options.sub_analysis_type); +md.analysis_type=EnumToString(options.analysis_type); +md.sub_analysis_type=EnumToString(options.sub_analysis_type); Index: sm/trunk/src/m/enum/EnumAsString.m =================================================================== --- /issm/trunk/src/m/enum/EnumAsString.m (revision 5102) +++ (revision ) @@ -1,306 +1,0 @@ -function string=EnumAsString(enum) -%ENUMASSTRING - output string associated with enum -% -% WARNING: DO NOT MODIFY THIS FILE -% this file has been automatically generated by src/c/SynchronizeMatlabEnum -% Please read src/c/README for more information -% -% Usage: -% string=EnumAsString(enum) - -switch enum, - - case ConstraintsEnum(), string='Constraints'; return - case DatasetsEnum(), string='Datasets'; return - case ElementsEnum(), string='Elements'; return - case LoadsEnum(), string='Loads'; return - case MaterialsEnum(), string='Materials'; return - case NodesEnum(), string='Nodes'; return - case ParametersEnum(), string='Parameters'; return - case ResultsEnum(), string='Results'; return - case VerticesEnum(), string='Vertices'; return - case SolutionTypeEnum(), string='SolutionType'; return - case AnalysisTypeEnum(), string='AnalysisType'; return - case ConfigurationTypeEnum(), string='ConfigurationType'; return - case SubAnalysisTypeEnum(), string='SubAnalysisType'; return - case AnalysisCounterEnum(), string='AnalysisCounter'; return - case DiagnosticSolutionEnum(), string='DiagnosticSolution'; return - case DiagnosticAnalysisEnum(), string='DiagnosticAnalysis'; return - case DiagnosticHorizAnalysisEnum(), string='DiagnosticHorizAnalysis'; return - case DiagnosticVertAnalysisEnum(), string='DiagnosticVertAnalysis'; return - case DiagnosticHutterAnalysisEnum(), string='DiagnosticHutterAnalysis'; return - case DiagnosticStokesAnalysisEnum(), string='DiagnosticStokesAnalysis'; return - case HorizAnalysisEnum(), string='HorizAnalysis'; return - case HutterAnalysisEnum(), string='HutterAnalysis'; return - case StokesAnalysisEnum(), string='StokesAnalysis'; return - case VertAnalysisEnum(), string='VertAnalysis'; return - case AdjointSolutionEnum(), string='AdjointSolution'; return - case AdjointHorizAnalysisEnum(), string='AdjointHorizAnalysis'; return - case AdjointStokesAnalysisEnum(), string='AdjointStokesAnalysis'; return - case ControlAnalysisEnum(), string='ControlAnalysis'; return - case GradientAnalysisEnum(), string='GradientAnalysis'; return - case InverseAnalysisEnum(), string='InverseAnalysis'; return - case ThermalSolutionEnum(), string='ThermalSolution'; return - case ThermalAnalysisEnum(), string='ThermalAnalysis'; return - case Transient2DSolutionEnum(), string='Transient2DSolution'; return - case Transient2DAnalysisEnum(), string='Transient2DAnalysis'; return - case Transient3DSolutionEnum(), string='Transient3DSolution'; return - case Transient3DAnalysisEnum(), string='Transient3DAnalysis'; return - case SteadyAnalysisEnum(), string='SteadyAnalysis'; return - case TransientAnalysisEnum(), string='TransientAnalysis'; return - case BedSlopeSolutionEnum(), string='BedSlopeSolution'; return - case BedSlopeAnalysisEnum(), string='BedSlopeAnalysis'; return - case SurfaceSlopeSolutionEnum(), string='SurfaceSlopeSolution'; return - case SurfaceSlopeAnalysisEnum(), string='SurfaceSlopeAnalysis'; return - case BedSlopeXAnalysisEnum(), string='BedSlopeXAnalysis'; return - case BedSlopeYAnalysisEnum(), string='BedSlopeYAnalysis'; return - case SurfaceSlopeXAnalysisEnum(), string='SurfaceSlopeXAnalysis'; return - case SurfaceSlopeYAnalysisEnum(), string='SurfaceSlopeYAnalysis'; return - case BalancedthicknessSolutionEnum(), string='BalancedthicknessSolution'; return - case BalancedthicknessAnalysisEnum(), string='BalancedthicknessAnalysis'; return - case BalancedvelocitiesSolutionEnum(), string='BalancedvelocitiesSolution'; return - case BalancedvelocitiesAnalysisEnum(), string='BalancedvelocitiesAnalysis'; return - case PrognosticSolutionEnum(), string='PrognosticSolution'; return - case PrognosticAnalysisEnum(), string='PrognosticAnalysis'; return - case MeltingAnalysisEnum(), string='MeltingAnalysis'; return - case ParametersSolutionEnum(), string='ParametersSolution'; return - case ParametersAnalysisEnum(), string='ParametersAnalysis'; return - case SteadystateSolutionEnum(), string='SteadystateSolution'; return - case SteadystateAnalysisEnum(), string='SteadystateAnalysis'; return - case NoneAnalysisEnum(), string='NoneAnalysis'; return - case FormulationEnum(), string='Formulation'; return - case HutterFormulationEnum(), string='HutterFormulation'; return - case MacAyealFormulationEnum(), string='MacAyealFormulation'; return - case MacAyealPattynFormulationEnum(), string='MacAyealPattynFormulation'; return - case NoneFormulationEnum(), string='NoneFormulation'; return - case PattynFormulationEnum(), string='PattynFormulation'; return - case StokesFormulationEnum(), string='StokesFormulation'; return - case ObjectEnum(), string='Object'; return - case HookEnum(), string='Hook'; return - case SegmentEnum(), string='Segment'; return - case ElementEnum(), string='Element'; return - case DofIndexingEnum(), string='DofIndexing'; return - case ElementPropertiesEnum(), string='ElementProperties'; return - case NodePropertiesEnum(), string='NodeProperties'; return - case PentaEnum(), string='Penta'; return - case TriaEnum(), string='Tria'; return - case NodeEnum(), string='Node'; return - case VertexEnum(), string='Vertex'; return - case LoadEnum(), string='Load'; return - case IcefrontEnum(), string='Icefront'; return - case NumericalfluxEnum(), string='Numericalflux'; return - case PengridEnum(), string='Pengrid'; return - case PenpairEnum(), string='Penpair'; return - case QuadIceFrontEnum(), string='QuadIceFront'; return - case QuadRiftFrontEnum(), string='QuadRiftFront'; return - case RiftfrontEnum(), string='Riftfront'; return - case SegmentIcefrontEnum(), string='SegmentIcefront'; return - case SegmentRiftfrontEnum(), string='SegmentRiftfront'; return - case MaterialEnum(), string='Material'; return - case MaticeEnum(), string='Matice'; return - case MatparEnum(), string='Matpar'; return - case InputEnum(), string='Input'; return - case BoolInputEnum(), string='BoolInput'; return - case DoubleInputEnum(), string='DoubleInput'; return - case IntInputEnum(), string='IntInput'; return - case PentaVertexInputEnum(), string='PentaVertexInput'; return - case TriaVertexInputEnum(), string='TriaVertexInput'; return - case ParamEnum(), string='Param'; return - case BoolParamEnum(), string='BoolParam'; return - case DoubleMatParamEnum(), string='DoubleMatParam'; return - case DoubleMatArrayParamEnum(), string='DoubleMatArrayParam'; return - case DoubleParamEnum(), string='DoubleParam'; return - case DoubleVecParamEnum(), string='DoubleVecParam'; return - case IntParamEnum(), string='IntParam'; return - case FileParamEnum(), string='FileParam'; return - case PetscMatParamEnum(), string='PetscMatParam'; return - case PetscVecParamEnum(), string='PetscVecParam'; return - case StringArrayParamEnum(), string='StringArrayParam'; return - case StringParamEnum(), string='StringParam'; return - case ElementResultEnum(), string='ElementResult'; return - case ExternalResultEnum(), string='ExternalResult'; return - case RgbEnum(), string='Rgb'; return - case SpcEnum(), string='Spc'; return - case GeographyEnum(), string='Geography'; return - case IceSheetEnum(), string='IceSheet'; return - case IceShelfEnum(), string='IceShelf'; return - case WaterEnum(), string='Water'; return - case IceEnum(), string='Ice'; return - case AirEnum(), string='Air'; return - case MelangeEnum(), string='Melange'; return - case AccumulationRateEnum(), string='AccumulationRate'; return - case AdjointxEnum(), string='Adjointx'; return - case AdjointyEnum(), string='Adjointy'; return - case AdjointzEnum(), string='Adjointz'; return - case AdjointpEnum(), string='Adjointp'; return - case ArtDiffEnum(), string='ArtDiff'; return - case BedEnum(), string='Bed'; return - case BedSlopeXEnum(), string='BedSlopeX'; return - case BedSlopeYEnum(), string='BedSlopeY'; return - case BoundaryEnum(), string='Boundary'; return - case CmMaxDmpSlopeEnum(), string='CmMaxDmpSlope'; return - case CmMaxDmpValueEnum(), string='CmMaxDmpValue'; return - case CmMinDmpSlopeEnum(), string='CmMinDmpSlope'; return - case CmMinDmpValueEnum(), string='CmMinDmpValue'; return - case CmNoiseDmpEnum(), string='CmNoiseDmp'; return - case CollapseEnum(), string='Collapse'; return - case ConstantEnum(), string='Constant'; return - case ControlTypeEnum(), string='ControlType'; return - case ConvergedEnum(), string='Converged'; return - case DhDtEnum(), string='DhDt'; return - case DragCoefficientEnum(), string='DragCoefficient'; return - case DragPEnum(), string='DragP'; return - case DragQEnum(), string='DragQ'; return - case DragTypeEnum(), string='DragType'; return - case DtEnum(), string='Dt'; return - case ElementOnBedEnum(), string='ElementOnBed'; return - case ElementOnIceShelfEnum(), string='ElementOnIceShelf'; return - case ElementOnSurfaceEnum(), string='ElementOnSurface'; return - case ElementOnWaterEnum(), string='ElementOnWater'; return - case EpsVelEnum(), string='EpsVel'; return - case FillEnum(), string='Fill'; return - case FitEnum(), string='Fit'; return - case FractionIncrementEnum(), string='FractionIncrement'; return - case FrictionEnum(), string='Friction'; return - case GeothermalFluxEnum(), string='GeothermalFlux'; return - case InternalEnum(), string='Internal'; return - case KflagEnum(), string='Kflag'; return - case MassFluxEnum(), string='MassFlux'; return - case MaxPenetrationEnum(), string='MaxPenetration'; return - case MeanVelEnum(), string='MeanVel'; return - case MeltingOffsetEnum(), string='MeltingOffset'; return - case MeltingRateEnum(), string='MeltingRate'; return - case MisfitEnum(), string='Misfit'; return - case NodeOnBedEnum(), string='NodeOnBed'; return - case NodeOnIceSheetEnum(), string='NodeOnIceSheet'; return - case NodeOnIceShelfEnum(), string='NodeOnIceShelf'; return - case NodeOnSurfaceEnum(), string='NodeOnSurface'; return - case NumberNodeToElementConnectivityEnum(), string='NumberNodeToElementConnectivity'; return - case PenaltyOffsetEnum(), string='PenaltyOffset'; return - case PflagEnum(), string='Pflag'; return - case PressureEnum(), string='Pressure'; return - case PressureOldEnum(), string='PressureOld'; return - case QmuPressureEnum(), string='QmuPressure'; return - case ResetPenaltiesEnum(), string='ResetPenalties'; return - case RheologyBEnum(), string='RheologyB'; return - case RheologyB2dEnum(), string='RheologyB2d'; return - case RheologyNEnum(), string='RheologyN'; return - case SegmentOnIceShelfEnum(), string='SegmentOnIceShelf'; return - case StabilizeConstraintsEnum(), string='StabilizeConstraints'; return - case StokesReconditioningEnum(), string='StokesReconditioning'; return - case SurfaceAreaEnum(), string='SurfaceArea'; return - case SurfaceEnum(), string='Surface'; return - case SurfaceSlopeXEnum(), string='SurfaceSlopeX'; return - case SurfaceSlopeYEnum(), string='SurfaceSlopeY'; return - case TemperatureEnum(), string='Temperature'; return - case TemperatureOldEnum(), string='TemperatureOld'; return - case ThicknessEnum(), string='Thickness'; return - case TypeEnum(), string='Type'; return - case VelEnum(), string='Vel'; return - case VelObsEnum(), string='VelObs'; return - case ViscosityOvershootEnum(), string='ViscosityOvershoot'; return - case VxAverageEnum(), string='VxAverage'; return - case VxEnum(), string='Vx'; return - case VxObsEnum(), string='VxObs'; return - case VxOldEnum(), string='VxOld'; return - case QmuVxEnum(), string='QmuVx'; return - case VyAverageEnum(), string='VyAverage'; return - case VyEnum(), string='Vy'; return - case VyObsEnum(), string='VyObs'; return - case VyOldEnum(), string='VyOld'; return - case QmuVyEnum(), string='QmuVy'; return - case VzAverageEnum(), string='VzAverage'; return - case VzEnum(), string='Vz'; return - case VzObsEnum(), string='VzObs'; return - case VzOldEnum(), string='VzOld'; return - case QmuVzEnum(), string='QmuVz'; return - case WeightsEnum(), string='Weights'; return - case P0Enum(), string='P0'; return - case P1Enum(), string='P1'; return - case P1DGEnum(), string='P1DG'; return - case MiniEnum(), string='Mini'; return - case DoubleElementResultEnum(), string='DoubleElementResult'; return - case TriaVertexElementResultEnum(), string='TriaVertexElementResult'; return - case PentaVertexElementResultEnum(), string='PentaVertexElementResult'; return - case BoolExternalResultEnum(), string='BoolExternalResult'; return - case DoubleExternalResultEnum(), string='DoubleExternalResult'; return - case DoubleVecExternalResultEnum(), string='DoubleVecExternalResult'; return - case DoubleMatExternalResultEnum(), string='DoubleMatExternalResult'; return - case IntExternalResultEnum(), string='IntExternalResult'; return - case PetscVecExternalResultEnum(), string='PetscVecExternalResult'; return - case StringExternalResultEnum(), string='StringExternalResult'; return - case JEnum(), string='J'; return - case PatchEnum(), string='Patch'; return - case PatchVerticesEnum(), string='PatchVertices'; return - case PatchNodesEnum(), string='PatchNodes'; return - case TimeEnum(), string='Time'; return - case RelativeEnum(), string='Relative'; return - case ResidualEnum(), string='Residual'; return - case AbsoluteEnum(), string='Absolute'; return - case RhoIceEnum(), string='RhoIce'; return - case RhoWaterEnum(), string='RhoWater'; return - case GravityEnum(), string='Gravity'; return - case ThermalConductivityEnum(), string='ThermalConductivity'; return - case MixedLayerCapacityEnum(), string='MixedLayerCapacity'; return - case ThermalExchangeVelocityEnum(), string='ThermalExchangeVelocity'; return - case IntersectEnum(), string='Intersect'; return - case ColinearEnum(), string='Colinear'; return - case SeparateEnum(), string='Separate'; return - case BetaEnum(), string='Beta'; return - case CmGradientEnum(), string='CmGradient'; return - case CmJumpEnum(), string='CmJump'; return - case CmMaxEnum(), string='CmMax'; return - case CmMinEnum(), string='CmMin'; return - case AdjointEnum(), string='Adjoint'; return - case GradientEnum(), string='Gradient'; return - case OldGradientEnum(), string='OldGradient'; return - case ConnectivityEnum(), string='Connectivity'; return - case ControlParameterEnum(), string='ControlParameter'; return - case ControlSteadyEnum(), string='ControlSteady'; return - case DakotaParameterEnum(), string='DakotaParameter'; return - case DimEnum(), string='Dim'; return - case EpsAbsEnum(), string='EpsAbs'; return - case EpsCmEnum(), string='EpsCm'; return - case EpsRelEnum(), string='EpsRel'; return - case EpsResEnum(), string='EpsRes'; return - case HeatCapacityEnum(), string='HeatCapacity'; return - case IsHutterEnum(), string='IsHutter'; return - case IsMacAyealPattynEnum(), string='IsMacAyealPattyn'; return - case IsStokesEnum(), string='IsStokes'; return - case LatentHeatEnum(), string='LatentHeat'; return - case LowmemEnum(), string='Lowmem'; return - case MaxIterEnum(), string='MaxIter'; return - case MaxNonlinearIterationsEnum(), string='MaxNonlinearIterations'; return - case MeltingPointEnum(), string='MeltingPoint'; return - case MinMechanicalConstraintsEnum(), string='MinMechanicalConstraints'; return - case MinThermalConstraintsEnum(), string='MinThermalConstraints'; return - case NStepsEnum(), string='NSteps'; return - case NdtEnum(), string='Ndt'; return - case NumOutputEnum(), string='NumOutput'; return - case NumRiftsEnum(), string='NumRifts'; return - case NumberOfDofsPerNodeEnum(), string='NumberOfDofsPerNode'; return - case NumberOfElementsEnum(), string='NumberOfElements'; return - case NumberOfNodesEnum(), string='NumberOfNodes'; return - case NumberOfVerticesEnum(), string='NumberOfVertices'; return - case OptScalEnum(), string='OptScal'; return - case OutputFilePointerEnum(), string='OutputFilePointer'; return - case ParameterOutputEnum(), string='ParameterOutput'; return - case PenaltyMeltingEnum(), string='PenaltyMelting'; return - case QmuAnalysisEnum(), string='QmuAnalysis'; return - case QmuErrNameEnum(), string='QmuErrName'; return - case QmuInNameEnum(), string='QmuInName'; return - case QmuMassFluxSegmentsEnum(), string='QmuMassFluxSegments'; return - case QmuNPartEnum(), string='QmuNPart'; return - case QmuOutNameEnum(), string='QmuOutName'; return - case QmuPartEnum(), string='QmuPart'; return - case ResponseDescriptorsEnum(), string='ResponseDescriptors'; return - case SolverStringEnum(), string='SolverString'; return - case SparsityEnum(), string='Sparsity'; return - case TolXEnum(), string='TolX'; return - case VariableDescriptorsEnum(), string='VariableDescriptors'; return - case VerboseEnum(), string='Verbose'; return - case WaitOnLockEnum(), string='WaitOnLock'; return - case YtsEnum(), string='Yts'; return - otherwise, error(['Enum ' num2str(enum) ' not found']); - -end Index: /issm/trunk/src/m/enum/EnumToString.m =================================================================== --- /issm/trunk/src/m/enum/EnumToString.m (revision 5103) +++ /issm/trunk/src/m/enum/EnumToString.m (revision 5103) @@ -0,0 +1,306 @@ +function string=EnumToString(enum) +%ENUMASSTRING - output string associated with enum +% +% WARNING: DO NOT MODIFY THIS FILE +% this file has been automatically generated by src/c/SynchronizeMatlabEnum +% Please read src/c/README for more information +% +% Usage: +% string=EnumToString(enum) + +switch enum, + + case ConstraintsEnum(), string='Constraints'; return + case DatasetsEnum(), string='Datasets'; return + case ElementsEnum(), string='Elements'; return + case LoadsEnum(), string='Loads'; return + case MaterialsEnum(), string='Materials'; return + case NodesEnum(), string='Nodes'; return + case ParametersEnum(), string='Parameters'; return + case ResultsEnum(), string='Results'; return + case VerticesEnum(), string='Vertices'; return + case SolutionTypeEnum(), string='SolutionType'; return + case AnalysisTypeEnum(), string='AnalysisType'; return + case ConfigurationTypeEnum(), string='ConfigurationType'; return + case SubAnalysisTypeEnum(), string='SubAnalysisType'; return + case AnalysisCounterEnum(), string='AnalysisCounter'; return + case DiagnosticSolutionEnum(), string='DiagnosticSolution'; return + case DiagnosticAnalysisEnum(), string='DiagnosticAnalysis'; return + case DiagnosticHorizAnalysisEnum(), string='DiagnosticHorizAnalysis'; return + case DiagnosticVertAnalysisEnum(), string='DiagnosticVertAnalysis'; return + case DiagnosticHutterAnalysisEnum(), string='DiagnosticHutterAnalysis'; return + case DiagnosticStokesAnalysisEnum(), string='DiagnosticStokesAnalysis'; return + case HorizAnalysisEnum(), string='HorizAnalysis'; return + case HutterAnalysisEnum(), string='HutterAnalysis'; return + case StokesAnalysisEnum(), string='StokesAnalysis'; return + case VertAnalysisEnum(), string='VertAnalysis'; return + case AdjointSolutionEnum(), string='AdjointSolution'; return + case AdjointHorizAnalysisEnum(), string='AdjointHorizAnalysis'; return + case AdjointStokesAnalysisEnum(), string='AdjointStokesAnalysis'; return + case ControlAnalysisEnum(), string='ControlAnalysis'; return + case GradientAnalysisEnum(), string='GradientAnalysis'; return + case InverseAnalysisEnum(), string='InverseAnalysis'; return + case ThermalSolutionEnum(), string='ThermalSolution'; return + case ThermalAnalysisEnum(), string='ThermalAnalysis'; return + case Transient2DSolutionEnum(), string='Transient2DSolution'; return + case Transient2DAnalysisEnum(), string='Transient2DAnalysis'; return + case Transient3DSolutionEnum(), string='Transient3DSolution'; return + case Transient3DAnalysisEnum(), string='Transient3DAnalysis'; return + case SteadyAnalysisEnum(), string='SteadyAnalysis'; return + case TransientAnalysisEnum(), string='TransientAnalysis'; return + case BedSlopeSolutionEnum(), string='BedSlopeSolution'; return + case BedSlopeAnalysisEnum(), string='BedSlopeAnalysis'; return + case SurfaceSlopeSolutionEnum(), string='SurfaceSlopeSolution'; return + case SurfaceSlopeAnalysisEnum(), string='SurfaceSlopeAnalysis'; return + case BedSlopeXAnalysisEnum(), string='BedSlopeXAnalysis'; return + case BedSlopeYAnalysisEnum(), string='BedSlopeYAnalysis'; return + case SurfaceSlopeXAnalysisEnum(), string='SurfaceSlopeXAnalysis'; return + case SurfaceSlopeYAnalysisEnum(), string='SurfaceSlopeYAnalysis'; return + case BalancedthicknessSolutionEnum(), string='BalancedthicknessSolution'; return + case BalancedthicknessAnalysisEnum(), string='BalancedthicknessAnalysis'; return + case BalancedvelocitiesSolutionEnum(), string='BalancedvelocitiesSolution'; return + case BalancedvelocitiesAnalysisEnum(), string='BalancedvelocitiesAnalysis'; return + case PrognosticSolutionEnum(), string='PrognosticSolution'; return + case PrognosticAnalysisEnum(), string='PrognosticAnalysis'; return + case MeltingAnalysisEnum(), string='MeltingAnalysis'; return + case ParametersSolutionEnum(), string='ParametersSolution'; return + case ParametersAnalysisEnum(), string='ParametersAnalysis'; return + case SteadystateSolutionEnum(), string='SteadystateSolution'; return + case SteadystateAnalysisEnum(), string='SteadystateAnalysis'; return + case NoneAnalysisEnum(), string='NoneAnalysis'; return + case FormulationEnum(), string='Formulation'; return + case HutterFormulationEnum(), string='HutterFormulation'; return + case MacAyealFormulationEnum(), string='MacAyealFormulation'; return + case MacAyealPattynFormulationEnum(), string='MacAyealPattynFormulation'; return + case NoneFormulationEnum(), string='NoneFormulation'; return + case PattynFormulationEnum(), string='PattynFormulation'; return + case StokesFormulationEnum(), string='StokesFormulation'; return + case ObjectEnum(), string='Object'; return + case HookEnum(), string='Hook'; return + case SegmentEnum(), string='Segment'; return + case ElementEnum(), string='Element'; return + case DofIndexingEnum(), string='DofIndexing'; return + case ElementPropertiesEnum(), string='ElementProperties'; return + case NodePropertiesEnum(), string='NodeProperties'; return + case PentaEnum(), string='Penta'; return + case TriaEnum(), string='Tria'; return + case NodeEnum(), string='Node'; return + case VertexEnum(), string='Vertex'; return + case LoadEnum(), string='Load'; return + case IcefrontEnum(), string='Icefront'; return + case NumericalfluxEnum(), string='Numericalflux'; return + case PengridEnum(), string='Pengrid'; return + case PenpairEnum(), string='Penpair'; return + case QuadIceFrontEnum(), string='QuadIceFront'; return + case QuadRiftFrontEnum(), string='QuadRiftFront'; return + case RiftfrontEnum(), string='Riftfront'; return + case SegmentIcefrontEnum(), string='SegmentIcefront'; return + case SegmentRiftfrontEnum(), string='SegmentRiftfront'; return + case MaterialEnum(), string='Material'; return + case MaticeEnum(), string='Matice'; return + case MatparEnum(), string='Matpar'; return + case InputEnum(), string='Input'; return + case BoolInputEnum(), string='BoolInput'; return + case DoubleInputEnum(), string='DoubleInput'; return + case IntInputEnum(), string='IntInput'; return + case PentaVertexInputEnum(), string='PentaVertexInput'; return + case TriaVertexInputEnum(), string='TriaVertexInput'; return + case ParamEnum(), string='Param'; return + case BoolParamEnum(), string='BoolParam'; return + case DoubleMatParamEnum(), string='DoubleMatParam'; return + case DoubleMatArrayParamEnum(), string='DoubleMatArrayParam'; return + case DoubleParamEnum(), string='DoubleParam'; return + case DoubleVecParamEnum(), string='DoubleVecParam'; return + case IntParamEnum(), string='IntParam'; return + case FileParamEnum(), string='FileParam'; return + case PetscMatParamEnum(), string='PetscMatParam'; return + case PetscVecParamEnum(), string='PetscVecParam'; return + case StringArrayParamEnum(), string='StringArrayParam'; return + case StringParamEnum(), string='StringParam'; return + case ElementResultEnum(), string='ElementResult'; return + case ExternalResultEnum(), string='ExternalResult'; return + case RgbEnum(), string='Rgb'; return + case SpcEnum(), string='Spc'; return + case GeographyEnum(), string='Geography'; return + case IceSheetEnum(), string='IceSheet'; return + case IceShelfEnum(), string='IceShelf'; return + case WaterEnum(), string='Water'; return + case IceEnum(), string='Ice'; return + case AirEnum(), string='Air'; return + case MelangeEnum(), string='Melange'; return + case AccumulationRateEnum(), string='AccumulationRate'; return + case AdjointxEnum(), string='Adjointx'; return + case AdjointyEnum(), string='Adjointy'; return + case AdjointzEnum(), string='Adjointz'; return + case AdjointpEnum(), string='Adjointp'; return + case ArtDiffEnum(), string='ArtDiff'; return + case BedEnum(), string='Bed'; return + case BedSlopeXEnum(), string='BedSlopeX'; return + case BedSlopeYEnum(), string='BedSlopeY'; return + case BoundaryEnum(), string='Boundary'; return + case CmMaxDmpSlopeEnum(), string='CmMaxDmpSlope'; return + case CmMaxDmpValueEnum(), string='CmMaxDmpValue'; return + case CmMinDmpSlopeEnum(), string='CmMinDmpSlope'; return + case CmMinDmpValueEnum(), string='CmMinDmpValue'; return + case CmNoiseDmpEnum(), string='CmNoiseDmp'; return + case CollapseEnum(), string='Collapse'; return + case ConstantEnum(), string='Constant'; return + case ControlTypeEnum(), string='ControlType'; return + case ConvergedEnum(), string='Converged'; return + case DhDtEnum(), string='DhDt'; return + case DragCoefficientEnum(), string='DragCoefficient'; return + case DragPEnum(), string='DragP'; return + case DragQEnum(), string='DragQ'; return + case DragTypeEnum(), string='DragType'; return + case DtEnum(), string='Dt'; return + case ElementOnBedEnum(), string='ElementOnBed'; return + case ElementOnIceShelfEnum(), string='ElementOnIceShelf'; return + case ElementOnSurfaceEnum(), string='ElementOnSurface'; return + case ElementOnWaterEnum(), string='ElementOnWater'; return + case EpsVelEnum(), string='EpsVel'; return + case FillEnum(), string='Fill'; return + case FitEnum(), string='Fit'; return + case FractionIncrementEnum(), string='FractionIncrement'; return + case FrictionEnum(), string='Friction'; return + case GeothermalFluxEnum(), string='GeothermalFlux'; return + case InternalEnum(), string='Internal'; return + case KflagEnum(), string='Kflag'; return + case MassFluxEnum(), string='MassFlux'; return + case MaxPenetrationEnum(), string='MaxPenetration'; return + case MeanVelEnum(), string='MeanVel'; return + case MeltingOffsetEnum(), string='MeltingOffset'; return + case MeltingRateEnum(), string='MeltingRate'; return + case MisfitEnum(), string='Misfit'; return + case NodeOnBedEnum(), string='NodeOnBed'; return + case NodeOnIceSheetEnum(), string='NodeOnIceSheet'; return + case NodeOnIceShelfEnum(), string='NodeOnIceShelf'; return + case NodeOnSurfaceEnum(), string='NodeOnSurface'; return + case NumberNodeToElementConnectivityEnum(), string='NumberNodeToElementConnectivity'; return + case PenaltyOffsetEnum(), string='PenaltyOffset'; return + case PflagEnum(), string='Pflag'; return + case PressureEnum(), string='Pressure'; return + case PressureOldEnum(), string='PressureOld'; return + case QmuPressureEnum(), string='QmuPressure'; return + case ResetPenaltiesEnum(), string='ResetPenalties'; return + case RheologyBEnum(), string='RheologyB'; return + case RheologyB2dEnum(), string='RheologyB2d'; return + case RheologyNEnum(), string='RheologyN'; return + case SegmentOnIceShelfEnum(), string='SegmentOnIceShelf'; return + case StabilizeConstraintsEnum(), string='StabilizeConstraints'; return + case StokesReconditioningEnum(), string='StokesReconditioning'; return + case SurfaceAreaEnum(), string='SurfaceArea'; return + case SurfaceEnum(), string='Surface'; return + case SurfaceSlopeXEnum(), string='SurfaceSlopeX'; return + case SurfaceSlopeYEnum(), string='SurfaceSlopeY'; return + case TemperatureEnum(), string='Temperature'; return + case TemperatureOldEnum(), string='TemperatureOld'; return + case ThicknessEnum(), string='Thickness'; return + case TypeEnum(), string='Type'; return + case VelEnum(), string='Vel'; return + case VelObsEnum(), string='VelObs'; return + case ViscosityOvershootEnum(), string='ViscosityOvershoot'; return + case VxAverageEnum(), string='VxAverage'; return + case VxEnum(), string='Vx'; return + case VxObsEnum(), string='VxObs'; return + case VxOldEnum(), string='VxOld'; return + case QmuVxEnum(), string='QmuVx'; return + case VyAverageEnum(), string='VyAverage'; return + case VyEnum(), string='Vy'; return + case VyObsEnum(), string='VyObs'; return + case VyOldEnum(), string='VyOld'; return + case QmuVyEnum(), string='QmuVy'; return + case VzAverageEnum(), string='VzAverage'; return + case VzEnum(), string='Vz'; return + case VzObsEnum(), string='VzObs'; return + case VzOldEnum(), string='VzOld'; return + case QmuVzEnum(), string='QmuVz'; return + case WeightsEnum(), string='Weights'; return + case P0Enum(), string='P0'; return + case P1Enum(), string='P1'; return + case P1DGEnum(), string='P1DG'; return + case MiniEnum(), string='Mini'; return + case DoubleElementResultEnum(), string='DoubleElementResult'; return + case TriaVertexElementResultEnum(), string='TriaVertexElementResult'; return + case PentaVertexElementResultEnum(), string='PentaVertexElementResult'; return + case BoolExternalResultEnum(), string='BoolExternalResult'; return + case DoubleExternalResultEnum(), string='DoubleExternalResult'; return + case DoubleVecExternalResultEnum(), string='DoubleVecExternalResult'; return + case DoubleMatExternalResultEnum(), string='DoubleMatExternalResult'; return + case IntExternalResultEnum(), string='IntExternalResult'; return + case PetscVecExternalResultEnum(), string='PetscVecExternalResult'; return + case StringExternalResultEnum(), string='StringExternalResult'; return + case JEnum(), string='J'; return + case PatchEnum(), string='Patch'; return + case PatchVerticesEnum(), string='PatchVertices'; return + case PatchNodesEnum(), string='PatchNodes'; return + case TimeEnum(), string='Time'; return + case RelativeEnum(), string='Relative'; return + case ResidualEnum(), string='Residual'; return + case AbsoluteEnum(), string='Absolute'; return + case RhoIceEnum(), string='RhoIce'; return + case RhoWaterEnum(), string='RhoWater'; return + case GravityEnum(), string='Gravity'; return + case ThermalConductivityEnum(), string='ThermalConductivity'; return + case MixedLayerCapacityEnum(), string='MixedLayerCapacity'; return + case ThermalExchangeVelocityEnum(), string='ThermalExchangeVelocity'; return + case IntersectEnum(), string='Intersect'; return + case ColinearEnum(), string='Colinear'; return + case SeparateEnum(), string='Separate'; return + case BetaEnum(), string='Beta'; return + case CmGradientEnum(), string='CmGradient'; return + case CmJumpEnum(), string='CmJump'; return + case CmMaxEnum(), string='CmMax'; return + case CmMinEnum(), string='CmMin'; return + case AdjointEnum(), string='Adjoint'; return + case GradientEnum(), string='Gradient'; return + case OldGradientEnum(), string='OldGradient'; return + case ConnectivityEnum(), string='Connectivity'; return + case ControlParameterEnum(), string='ControlParameter'; return + case ControlSteadyEnum(), string='ControlSteady'; return + case DakotaParameterEnum(), string='DakotaParameter'; return + case DimEnum(), string='Dim'; return + case EpsAbsEnum(), string='EpsAbs'; return + case EpsCmEnum(), string='EpsCm'; return + case EpsRelEnum(), string='EpsRel'; return + case EpsResEnum(), string='EpsRes'; return + case HeatCapacityEnum(), string='HeatCapacity'; return + case IsHutterEnum(), string='IsHutter'; return + case IsMacAyealPattynEnum(), string='IsMacAyealPattyn'; return + case IsStokesEnum(), string='IsStokes'; return + case LatentHeatEnum(), string='LatentHeat'; return + case LowmemEnum(), string='Lowmem'; return + case MaxIterEnum(), string='MaxIter'; return + case MaxNonlinearIterationsEnum(), string='MaxNonlinearIterations'; return + case MeltingPointEnum(), string='MeltingPoint'; return + case MinMechanicalConstraintsEnum(), string='MinMechanicalConstraints'; return + case MinThermalConstraintsEnum(), string='MinThermalConstraints'; return + case NStepsEnum(), string='NSteps'; return + case NdtEnum(), string='Ndt'; return + case NumOutputEnum(), string='NumOutput'; return + case NumRiftsEnum(), string='NumRifts'; return + case NumberOfDofsPerNodeEnum(), string='NumberOfDofsPerNode'; return + case NumberOfElementsEnum(), string='NumberOfElements'; return + case NumberOfNodesEnum(), string='NumberOfNodes'; return + case NumberOfVerticesEnum(), string='NumberOfVertices'; return + case OptScalEnum(), string='OptScal'; return + case OutputFilePointerEnum(), string='OutputFilePointer'; return + case ParameterOutputEnum(), string='ParameterOutput'; return + case PenaltyMeltingEnum(), string='PenaltyMelting'; return + case QmuAnalysisEnum(), string='QmuAnalysis'; return + case QmuErrNameEnum(), string='QmuErrName'; return + case QmuInNameEnum(), string='QmuInName'; return + case QmuMassFluxSegmentsEnum(), string='QmuMassFluxSegments'; return + case QmuNPartEnum(), string='QmuNPart'; return + case QmuOutNameEnum(), string='QmuOutName'; return + case QmuPartEnum(), string='QmuPart'; return + case ResponseDescriptorsEnum(), string='ResponseDescriptors'; return + case SolverStringEnum(), string='SolverString'; return + case SparsityEnum(), string='Sparsity'; return + case TolXEnum(), string='TolX'; return + case VariableDescriptorsEnum(), string='VariableDescriptors'; return + case VerboseEnum(), string='Verbose'; return + case WaitOnLockEnum(), string='WaitOnLock'; return + case YtsEnum(), string='Yts'; return + otherwise, error(['Enum ' num2str(enum) ' not found']); + +end Index: sm/trunk/src/m/enum/StringAsEnum.m =================================================================== --- /issm/trunk/src/m/enum/StringAsEnum.m (revision 5102) +++ (revision ) @@ -1,304 +1,0 @@ -function enum=StringAsEnum(name) -%STRINGASENUM - output enum associated with string -% -% WARNING: DO NOT MODIFY THIS FILE -% this file has been automatically generated by src/c/SynchronizeMatlabEnum -% Please read src/c/README for more information -% -% Usage: -% enum=StringAsEnum(name) - -if (strcmpi(name,'Constraints')), enum=ConstraintsEnum(); return -elseif (strcmpi(name,'Datasets')), enum=DatasetsEnum(); return -elseif (strcmpi(name,'Elements')), enum=ElementsEnum(); return -elseif (strcmpi(name,'Loads')), enum=LoadsEnum(); return -elseif (strcmpi(name,'Materials')), enum=MaterialsEnum(); return -elseif (strcmpi(name,'Nodes')), enum=NodesEnum(); return -elseif (strcmpi(name,'Parameters')), enum=ParametersEnum(); return -elseif (strcmpi(name,'Results')), enum=ResultsEnum(); return -elseif (strcmpi(name,'Vertices')), enum=VerticesEnum(); return -elseif (strcmpi(name,'SolutionType')), enum=SolutionTypeEnum(); return -elseif (strcmpi(name,'AnalysisType')), enum=AnalysisTypeEnum(); return -elseif (strcmpi(name,'ConfigurationType')), enum=ConfigurationTypeEnum(); return -elseif (strcmpi(name,'SubAnalysisType')), enum=SubAnalysisTypeEnum(); return -elseif (strcmpi(name,'AnalysisCounter')), enum=AnalysisCounterEnum(); return -elseif (strcmpi(name,'DiagnosticSolution')), enum=DiagnosticSolutionEnum(); return -elseif (strcmpi(name,'DiagnosticAnalysis')), enum=DiagnosticAnalysisEnum(); return -elseif (strcmpi(name,'DiagnosticHorizAnalysis')), enum=DiagnosticHorizAnalysisEnum(); return -elseif (strcmpi(name,'DiagnosticVertAnalysis')), enum=DiagnosticVertAnalysisEnum(); return -elseif (strcmpi(name,'DiagnosticHutterAnalysis')), enum=DiagnosticHutterAnalysisEnum(); return -elseif (strcmpi(name,'DiagnosticStokesAnalysis')), enum=DiagnosticStokesAnalysisEnum(); return -elseif (strcmpi(name,'HorizAnalysis')), enum=HorizAnalysisEnum(); return -elseif (strcmpi(name,'HutterAnalysis')), enum=HutterAnalysisEnum(); return -elseif (strcmpi(name,'StokesAnalysis')), enum=StokesAnalysisEnum(); return -elseif (strcmpi(name,'VertAnalysis')), enum=VertAnalysisEnum(); return -elseif (strcmpi(name,'AdjointSolution')), enum=AdjointSolutionEnum(); return -elseif (strcmpi(name,'AdjointHorizAnalysis')), enum=AdjointHorizAnalysisEnum(); return -elseif (strcmpi(name,'AdjointStokesAnalysis')), enum=AdjointStokesAnalysisEnum(); return -elseif (strcmpi(name,'ControlAnalysis')), enum=ControlAnalysisEnum(); return -elseif (strcmpi(name,'GradientAnalysis')), enum=GradientAnalysisEnum(); return -elseif (strcmpi(name,'InverseAnalysis')), enum=InverseAnalysisEnum(); return -elseif (strcmpi(name,'ThermalSolution')), enum=ThermalSolutionEnum(); return -elseif (strcmpi(name,'ThermalAnalysis')), enum=ThermalAnalysisEnum(); return -elseif (strcmpi(name,'Transient2DSolution')), enum=Transient2DSolutionEnum(); return -elseif (strcmpi(name,'Transient2DAnalysis')), enum=Transient2DAnalysisEnum(); return -elseif (strcmpi(name,'Transient3DSolution')), enum=Transient3DSolutionEnum(); return -elseif (strcmpi(name,'Transient3DAnalysis')), enum=Transient3DAnalysisEnum(); return -elseif (strcmpi(name,'SteadyAnalysis')), enum=SteadyAnalysisEnum(); return -elseif (strcmpi(name,'TransientAnalysis')), enum=TransientAnalysisEnum(); return -elseif (strcmpi(name,'BedSlopeSolution')), enum=BedSlopeSolutionEnum(); return -elseif (strcmpi(name,'BedSlopeAnalysis')), enum=BedSlopeAnalysisEnum(); return -elseif (strcmpi(name,'SurfaceSlopeSolution')), enum=SurfaceSlopeSolutionEnum(); return -elseif (strcmpi(name,'SurfaceSlopeAnalysis')), enum=SurfaceSlopeAnalysisEnum(); return -elseif (strcmpi(name,'BedSlopeXAnalysis')), enum=BedSlopeXAnalysisEnum(); return -elseif (strcmpi(name,'BedSlopeYAnalysis')), enum=BedSlopeYAnalysisEnum(); return -elseif (strcmpi(name,'SurfaceSlopeXAnalysis')), enum=SurfaceSlopeXAnalysisEnum(); return -elseif (strcmpi(name,'SurfaceSlopeYAnalysis')), enum=SurfaceSlopeYAnalysisEnum(); return -elseif (strcmpi(name,'BalancedthicknessSolution')), enum=BalancedthicknessSolutionEnum(); return -elseif (strcmpi(name,'BalancedthicknessAnalysis')), enum=BalancedthicknessAnalysisEnum(); return -elseif (strcmpi(name,'BalancedvelocitiesSolution')), enum=BalancedvelocitiesSolutionEnum(); return -elseif (strcmpi(name,'BalancedvelocitiesAnalysis')), enum=BalancedvelocitiesAnalysisEnum(); return -elseif (strcmpi(name,'PrognosticSolution')), enum=PrognosticSolutionEnum(); return -elseif (strcmpi(name,'PrognosticAnalysis')), enum=PrognosticAnalysisEnum(); return -elseif (strcmpi(name,'MeltingAnalysis')), enum=MeltingAnalysisEnum(); return -elseif (strcmpi(name,'ParametersSolution')), enum=ParametersSolutionEnum(); return -elseif (strcmpi(name,'ParametersAnalysis')), enum=ParametersAnalysisEnum(); return -elseif (strcmpi(name,'SteadystateSolution')), enum=SteadystateSolutionEnum(); return -elseif (strcmpi(name,'SteadystateAnalysis')), enum=SteadystateAnalysisEnum(); return -elseif (strcmpi(name,'NoneAnalysis')), enum=NoneAnalysisEnum(); return -elseif (strcmpi(name,'Formulation')), enum=FormulationEnum(); return -elseif (strcmpi(name,'HutterFormulation')), enum=HutterFormulationEnum(); return -elseif (strcmpi(name,'MacAyealFormulation')), enum=MacAyealFormulationEnum(); return -elseif (strcmpi(name,'MacAyealPattynFormulation')), enum=MacAyealPattynFormulationEnum(); return -elseif (strcmpi(name,'NoneFormulation')), enum=NoneFormulationEnum(); return -elseif (strcmpi(name,'PattynFormulation')), enum=PattynFormulationEnum(); return -elseif (strcmpi(name,'StokesFormulation')), enum=StokesFormulationEnum(); return -elseif (strcmpi(name,'Object')), enum=ObjectEnum(); return -elseif (strcmpi(name,'Hook')), enum=HookEnum(); return -elseif (strcmpi(name,'Segment')), enum=SegmentEnum(); return -elseif (strcmpi(name,'Element')), enum=ElementEnum(); return -elseif (strcmpi(name,'DofIndexing')), enum=DofIndexingEnum(); return -elseif (strcmpi(name,'ElementProperties')), enum=ElementPropertiesEnum(); return -elseif (strcmpi(name,'NodeProperties')), enum=NodePropertiesEnum(); return -elseif (strcmpi(name,'Penta')), enum=PentaEnum(); return -elseif (strcmpi(name,'Tria')), enum=TriaEnum(); return -elseif (strcmpi(name,'Node')), enum=NodeEnum(); return -elseif (strcmpi(name,'Vertex')), enum=VertexEnum(); return -elseif (strcmpi(name,'Load')), enum=LoadEnum(); return -elseif (strcmpi(name,'Icefront')), enum=IcefrontEnum(); return -elseif (strcmpi(name,'Numericalflux')), enum=NumericalfluxEnum(); return -elseif (strcmpi(name,'Pengrid')), enum=PengridEnum(); return -elseif (strcmpi(name,'Penpair')), enum=PenpairEnum(); return -elseif (strcmpi(name,'QuadIceFront')), enum=QuadIceFrontEnum(); return -elseif (strcmpi(name,'QuadRiftFront')), enum=QuadRiftFrontEnum(); return -elseif (strcmpi(name,'Riftfront')), enum=RiftfrontEnum(); return -elseif (strcmpi(name,'SegmentIcefront')), enum=SegmentIcefrontEnum(); return -elseif (strcmpi(name,'SegmentRiftfront')), enum=SegmentRiftfrontEnum(); return -elseif (strcmpi(name,'Material')), enum=MaterialEnum(); return -elseif (strcmpi(name,'Matice')), enum=MaticeEnum(); return -elseif (strcmpi(name,'Matpar')), enum=MatparEnum(); return -elseif (strcmpi(name,'Input')), enum=InputEnum(); return -elseif (strcmpi(name,'BoolInput')), enum=BoolInputEnum(); return -elseif (strcmpi(name,'DoubleInput')), enum=DoubleInputEnum(); return -elseif (strcmpi(name,'IntInput')), enum=IntInputEnum(); return -elseif (strcmpi(name,'PentaVertexInput')), enum=PentaVertexInputEnum(); return -elseif (strcmpi(name,'TriaVertexInput')), enum=TriaVertexInputEnum(); return -elseif (strcmpi(name,'Param')), enum=ParamEnum(); return -elseif (strcmpi(name,'BoolParam')), enum=BoolParamEnum(); return -elseif (strcmpi(name,'DoubleMatParam')), enum=DoubleMatParamEnum(); return -elseif (strcmpi(name,'DoubleMatArrayParam')), enum=DoubleMatArrayParamEnum(); return -elseif (strcmpi(name,'DoubleParam')), enum=DoubleParamEnum(); return -elseif (strcmpi(name,'DoubleVecParam')), enum=DoubleVecParamEnum(); return -elseif (strcmpi(name,'IntParam')), enum=IntParamEnum(); return -elseif (strcmpi(name,'FileParam')), enum=FileParamEnum(); return -elseif (strcmpi(name,'PetscMatParam')), enum=PetscMatParamEnum(); return -elseif (strcmpi(name,'PetscVecParam')), enum=PetscVecParamEnum(); return -elseif (strcmpi(name,'StringArrayParam')), enum=StringArrayParamEnum(); return -elseif (strcmpi(name,'StringParam')), enum=StringParamEnum(); return -elseif (strcmpi(name,'ElementResult')), enum=ElementResultEnum(); return -elseif (strcmpi(name,'ExternalResult')), enum=ExternalResultEnum(); return -elseif (strcmpi(name,'Rgb')), enum=RgbEnum(); return -elseif (strcmpi(name,'Spc')), enum=SpcEnum(); return -elseif (strcmpi(name,'Geography')), enum=GeographyEnum(); return -elseif (strcmpi(name,'IceSheet')), enum=IceSheetEnum(); return -elseif (strcmpi(name,'IceShelf')), enum=IceShelfEnum(); return -elseif (strcmpi(name,'Water')), enum=WaterEnum(); return -elseif (strcmpi(name,'Ice')), enum=IceEnum(); return -elseif (strcmpi(name,'Air')), enum=AirEnum(); return -elseif (strcmpi(name,'Melange')), enum=MelangeEnum(); return -elseif (strcmpi(name,'AccumulationRate')), enum=AccumulationRateEnum(); return -elseif (strcmpi(name,'Adjointx')), enum=AdjointxEnum(); return -elseif (strcmpi(name,'Adjointy')), enum=AdjointyEnum(); return -elseif (strcmpi(name,'Adjointz')), enum=AdjointzEnum(); return -elseif (strcmpi(name,'Adjointp')), enum=AdjointpEnum(); return -elseif (strcmpi(name,'ArtDiff')), enum=ArtDiffEnum(); return -elseif (strcmpi(name,'Bed')), enum=BedEnum(); return -elseif (strcmpi(name,'BedSlopeX')), enum=BedSlopeXEnum(); return -elseif (strcmpi(name,'BedSlopeY')), enum=BedSlopeYEnum(); return -elseif (strcmpi(name,'Boundary')), enum=BoundaryEnum(); return -elseif (strcmpi(name,'CmMaxDmpSlope')), enum=CmMaxDmpSlopeEnum(); return -elseif (strcmpi(name,'CmMaxDmpValue')), enum=CmMaxDmpValueEnum(); return -elseif (strcmpi(name,'CmMinDmpSlope')), enum=CmMinDmpSlopeEnum(); return -elseif (strcmpi(name,'CmMinDmpValue')), enum=CmMinDmpValueEnum(); return -elseif (strcmpi(name,'CmNoiseDmp')), enum=CmNoiseDmpEnum(); return -elseif (strcmpi(name,'Collapse')), enum=CollapseEnum(); return -elseif (strcmpi(name,'Constant')), enum=ConstantEnum(); return -elseif (strcmpi(name,'ControlType')), enum=ControlTypeEnum(); return -elseif (strcmpi(name,'Converged')), enum=ConvergedEnum(); return -elseif (strcmpi(name,'DhDt')), enum=DhDtEnum(); return -elseif (strcmpi(name,'DragCoefficient')), enum=DragCoefficientEnum(); return -elseif (strcmpi(name,'DragP')), enum=DragPEnum(); return -elseif (strcmpi(name,'DragQ')), enum=DragQEnum(); return -elseif (strcmpi(name,'DragType')), enum=DragTypeEnum(); return -elseif (strcmpi(name,'Dt')), enum=DtEnum(); return -elseif (strcmpi(name,'ElementOnBed')), enum=ElementOnBedEnum(); return -elseif (strcmpi(name,'ElementOnIceShelf')), enum=ElementOnIceShelfEnum(); return -elseif (strcmpi(name,'ElementOnSurface')), enum=ElementOnSurfaceEnum(); return -elseif (strcmpi(name,'ElementOnWater')), enum=ElementOnWaterEnum(); return -elseif (strcmpi(name,'EpsVel')), enum=EpsVelEnum(); return -elseif (strcmpi(name,'Fill')), enum=FillEnum(); return -elseif (strcmpi(name,'Fit')), enum=FitEnum(); return -elseif (strcmpi(name,'FractionIncrement')), enum=FractionIncrementEnum(); return -elseif (strcmpi(name,'Friction')), enum=FrictionEnum(); return -elseif (strcmpi(name,'GeothermalFlux')), enum=GeothermalFluxEnum(); return -elseif (strcmpi(name,'Internal')), enum=InternalEnum(); return -elseif (strcmpi(name,'Kflag')), enum=KflagEnum(); return -elseif (strcmpi(name,'MassFlux')), enum=MassFluxEnum(); return -elseif (strcmpi(name,'MaxPenetration')), enum=MaxPenetrationEnum(); return -elseif (strcmpi(name,'MeanVel')), enum=MeanVelEnum(); return -elseif (strcmpi(name,'MeltingOffset')), enum=MeltingOffsetEnum(); return -elseif (strcmpi(name,'MeltingRate')), enum=MeltingRateEnum(); return -elseif (strcmpi(name,'Misfit')), enum=MisfitEnum(); return -elseif (strcmpi(name,'NodeOnBed')), enum=NodeOnBedEnum(); return -elseif (strcmpi(name,'NodeOnIceSheet')), enum=NodeOnIceSheetEnum(); return -elseif (strcmpi(name,'NodeOnIceShelf')), enum=NodeOnIceShelfEnum(); return -elseif (strcmpi(name,'NodeOnSurface')), enum=NodeOnSurfaceEnum(); return -elseif (strcmpi(name,'NumberNodeToElementConnectivity')), enum=NumberNodeToElementConnectivityEnum(); return -elseif (strcmpi(name,'PenaltyOffset')), enum=PenaltyOffsetEnum(); return -elseif (strcmpi(name,'Pflag')), enum=PflagEnum(); return -elseif (strcmpi(name,'Pressure')), enum=PressureEnum(); return -elseif (strcmpi(name,'PressureOld')), enum=PressureOldEnum(); return -elseif (strcmpi(name,'QmuPressure')), enum=QmuPressureEnum(); return -elseif (strcmpi(name,'ResetPenalties')), enum=ResetPenaltiesEnum(); return -elseif (strcmpi(name,'RheologyB')), enum=RheologyBEnum(); return -elseif (strcmpi(name,'RheologyB2d')), enum=RheologyB2dEnum(); return -elseif (strcmpi(name,'RheologyN')), enum=RheologyNEnum(); return -elseif (strcmpi(name,'SegmentOnIceShelf')), enum=SegmentOnIceShelfEnum(); return -elseif (strcmpi(name,'StabilizeConstraints')), enum=StabilizeConstraintsEnum(); return -elseif (strcmpi(name,'StokesReconditioning')), enum=StokesReconditioningEnum(); return -elseif (strcmpi(name,'SurfaceArea')), enum=SurfaceAreaEnum(); return -elseif (strcmpi(name,'Surface')), enum=SurfaceEnum(); return -elseif (strcmpi(name,'SurfaceSlopeX')), enum=SurfaceSlopeXEnum(); return -elseif (strcmpi(name,'SurfaceSlopeY')), enum=SurfaceSlopeYEnum(); return -elseif (strcmpi(name,'Temperature')), enum=TemperatureEnum(); return -elseif (strcmpi(name,'TemperatureOld')), enum=TemperatureOldEnum(); return -elseif (strcmpi(name,'Thickness')), enum=ThicknessEnum(); return -elseif (strcmpi(name,'Type')), enum=TypeEnum(); return -elseif (strcmpi(name,'Vel')), enum=VelEnum(); return -elseif (strcmpi(name,'VelObs')), enum=VelObsEnum(); return -elseif (strcmpi(name,'ViscosityOvershoot')), enum=ViscosityOvershootEnum(); return -elseif (strcmpi(name,'VxAverage')), enum=VxAverageEnum(); return -elseif (strcmpi(name,'Vx')), enum=VxEnum(); return -elseif (strcmpi(name,'VxObs')), enum=VxObsEnum(); return -elseif (strcmpi(name,'VxOld')), enum=VxOldEnum(); return -elseif (strcmpi(name,'QmuVx')), enum=QmuVxEnum(); return -elseif (strcmpi(name,'VyAverage')), enum=VyAverageEnum(); return -elseif (strcmpi(name,'Vy')), enum=VyEnum(); return -elseif (strcmpi(name,'VyObs')), enum=VyObsEnum(); return -elseif (strcmpi(name,'VyOld')), enum=VyOldEnum(); return -elseif (strcmpi(name,'QmuVy')), enum=QmuVyEnum(); return -elseif (strcmpi(name,'VzAverage')), enum=VzAverageEnum(); return -elseif (strcmpi(name,'Vz')), enum=VzEnum(); return -elseif (strcmpi(name,'VzObs')), enum=VzObsEnum(); return -elseif (strcmpi(name,'VzOld')), enum=VzOldEnum(); return -elseif (strcmpi(name,'QmuVz')), enum=QmuVzEnum(); return -elseif (strcmpi(name,'Weights')), enum=WeightsEnum(); return -elseif (strcmpi(name,'P0')), enum=P0Enum(); return -elseif (strcmpi(name,'P1')), enum=P1Enum(); return -elseif (strcmpi(name,'P1DG')), enum=P1DGEnum(); return -elseif (strcmpi(name,'Mini')), enum=MiniEnum(); return -elseif (strcmpi(name,'DoubleElementResult')), enum=DoubleElementResultEnum(); return -elseif (strcmpi(name,'TriaVertexElementResult')), enum=TriaVertexElementResultEnum(); return -elseif (strcmpi(name,'PentaVertexElementResult')), enum=PentaVertexElementResultEnum(); return -elseif (strcmpi(name,'BoolExternalResult')), enum=BoolExternalResultEnum(); return -elseif (strcmpi(name,'DoubleExternalResult')), enum=DoubleExternalResultEnum(); return -elseif (strcmpi(name,'DoubleVecExternalResult')), enum=DoubleVecExternalResultEnum(); return -elseif (strcmpi(name,'DoubleMatExternalResult')), enum=DoubleMatExternalResultEnum(); return -elseif (strcmpi(name,'IntExternalResult')), enum=IntExternalResultEnum(); return -elseif (strcmpi(name,'PetscVecExternalResult')), enum=PetscVecExternalResultEnum(); return -elseif (strcmpi(name,'StringExternalResult')), enum=StringExternalResultEnum(); return -elseif (strcmpi(name,'J')), enum=JEnum(); return -elseif (strcmpi(name,'Patch')), enum=PatchEnum(); return -elseif (strcmpi(name,'PatchVertices')), enum=PatchVerticesEnum(); return -elseif (strcmpi(name,'PatchNodes')), enum=PatchNodesEnum(); return -elseif (strcmpi(name,'Time')), enum=TimeEnum(); return -elseif (strcmpi(name,'Relative')), enum=RelativeEnum(); return -elseif (strcmpi(name,'Residual')), enum=ResidualEnum(); return -elseif (strcmpi(name,'Absolute')), enum=AbsoluteEnum(); return -elseif (strcmpi(name,'RhoIce')), enum=RhoIceEnum(); return -elseif (strcmpi(name,'RhoWater')), enum=RhoWaterEnum(); return -elseif (strcmpi(name,'Gravity')), enum=GravityEnum(); return -elseif (strcmpi(name,'ThermalConductivity')), enum=ThermalConductivityEnum(); return -elseif (strcmpi(name,'MixedLayerCapacity')), enum=MixedLayerCapacityEnum(); return -elseif (strcmpi(name,'ThermalExchangeVelocity')), enum=ThermalExchangeVelocityEnum(); return -elseif (strcmpi(name,'Intersect')), enum=IntersectEnum(); return -elseif (strcmpi(name,'Colinear')), enum=ColinearEnum(); return -elseif (strcmpi(name,'Separate')), enum=SeparateEnum(); return -elseif (strcmpi(name,'Beta')), enum=BetaEnum(); return -elseif (strcmpi(name,'CmGradient')), enum=CmGradientEnum(); return -elseif (strcmpi(name,'CmJump')), enum=CmJumpEnum(); return -elseif (strcmpi(name,'CmMax')), enum=CmMaxEnum(); return -elseif (strcmpi(name,'CmMin')), enum=CmMinEnum(); return -elseif (strcmpi(name,'Adjoint')), enum=AdjointEnum(); return -elseif (strcmpi(name,'Gradient')), enum=GradientEnum(); return -elseif (strcmpi(name,'OldGradient')), enum=OldGradientEnum(); return -elseif (strcmpi(name,'Connectivity')), enum=ConnectivityEnum(); return -elseif (strcmpi(name,'ControlParameter')), enum=ControlParameterEnum(); return -elseif (strcmpi(name,'ControlSteady')), enum=ControlSteadyEnum(); return -elseif (strcmpi(name,'DakotaParameter')), enum=DakotaParameterEnum(); return -elseif (strcmpi(name,'Dim')), enum=DimEnum(); return -elseif (strcmpi(name,'EpsAbs')), enum=EpsAbsEnum(); return -elseif (strcmpi(name,'EpsCm')), enum=EpsCmEnum(); return -elseif (strcmpi(name,'EpsRel')), enum=EpsRelEnum(); return -elseif (strcmpi(name,'EpsRes')), enum=EpsResEnum(); return -elseif (strcmpi(name,'HeatCapacity')), enum=HeatCapacityEnum(); return -elseif (strcmpi(name,'IsHutter')), enum=IsHutterEnum(); return -elseif (strcmpi(name,'IsMacAyealPattyn')), enum=IsMacAyealPattynEnum(); return -elseif (strcmpi(name,'IsStokes')), enum=IsStokesEnum(); return -elseif (strcmpi(name,'LatentHeat')), enum=LatentHeatEnum(); return -elseif (strcmpi(name,'Lowmem')), enum=LowmemEnum(); return -elseif (strcmpi(name,'MaxIter')), enum=MaxIterEnum(); return -elseif (strcmpi(name,'MaxNonlinearIterations')), enum=MaxNonlinearIterationsEnum(); return -elseif (strcmpi(name,'MeltingPoint')), enum=MeltingPointEnum(); return -elseif (strcmpi(name,'MinMechanicalConstraints')), enum=MinMechanicalConstraintsEnum(); return -elseif (strcmpi(name,'MinThermalConstraints')), enum=MinThermalConstraintsEnum(); return -elseif (strcmpi(name,'NSteps')), enum=NStepsEnum(); return -elseif (strcmpi(name,'Ndt')), enum=NdtEnum(); return -elseif (strcmpi(name,'NumOutput')), enum=NumOutputEnum(); return -elseif (strcmpi(name,'NumRifts')), enum=NumRiftsEnum(); return -elseif (strcmpi(name,'NumberOfDofsPerNode')), enum=NumberOfDofsPerNodeEnum(); return -elseif (strcmpi(name,'NumberOfElements')), enum=NumberOfElementsEnum(); return -elseif (strcmpi(name,'NumberOfNodes')), enum=NumberOfNodesEnum(); return -elseif (strcmpi(name,'NumberOfVertices')), enum=NumberOfVerticesEnum(); return -elseif (strcmpi(name,'OptScal')), enum=OptScalEnum(); return -elseif (strcmpi(name,'OutputFilePointer')), enum=OutputFilePointerEnum(); return -elseif (strcmpi(name,'ParameterOutput')), enum=ParameterOutputEnum(); return -elseif (strcmpi(name,'PenaltyMelting')), enum=PenaltyMeltingEnum(); return -elseif (strcmpi(name,'QmuAnalysis')), enum=QmuAnalysisEnum(); return -elseif (strcmpi(name,'QmuErrName')), enum=QmuErrNameEnum(); return -elseif (strcmpi(name,'QmuInName')), enum=QmuInNameEnum(); return -elseif (strcmpi(name,'QmuMassFluxSegments')), enum=QmuMassFluxSegmentsEnum(); return -elseif (strcmpi(name,'QmuNPart')), enum=QmuNPartEnum(); return -elseif (strcmpi(name,'QmuOutName')), enum=QmuOutNameEnum(); return -elseif (strcmpi(name,'QmuPart')), enum=QmuPartEnum(); return -elseif (strcmpi(name,'ResponseDescriptors')), enum=ResponseDescriptorsEnum(); return -elseif (strcmpi(name,'SolverString')), enum=SolverStringEnum(); return -elseif (strcmpi(name,'Sparsity')), enum=SparsityEnum(); return -elseif (strcmpi(name,'TolX')), enum=TolXEnum(); return -elseif (strcmpi(name,'VariableDescriptors')), enum=VariableDescriptorsEnum(); return -elseif (strcmpi(name,'Verbose')), enum=VerboseEnum(); return -elseif (strcmpi(name,'WaitOnLock')), enum=WaitOnLockEnum(); return -elseif (strcmpi(name,'Yts')), enum=YtsEnum(); return -else error(['Enum ' name ' not found']); - -end Index: /issm/trunk/src/m/enum/StringToEnum.m =================================================================== --- /issm/trunk/src/m/enum/StringToEnum.m (revision 5103) +++ /issm/trunk/src/m/enum/StringToEnum.m (revision 5103) @@ -0,0 +1,304 @@ +function enum=StringToEnum(name) +%STRINGASENUM - output enum associated with string +% +% WARNING: DO NOT MODIFY THIS FILE +% this file has been automatically generated by src/c/SynchronizeMatlabEnum +% Please read src/c/README for more information +% +% Usage: +% enum=StringToEnum(name) + +if (strcmpi(name,'Constraints')), enum=ConstraintsEnum(); return +elseif (strcmpi(name,'Datasets')), enum=DatasetsEnum(); return +elseif (strcmpi(name,'Elements')), enum=ElementsEnum(); return +elseif (strcmpi(name,'Loads')), enum=LoadsEnum(); return +elseif (strcmpi(name,'Materials')), enum=MaterialsEnum(); return +elseif (strcmpi(name,'Nodes')), enum=NodesEnum(); return +elseif (strcmpi(name,'Parameters')), enum=ParametersEnum(); return +elseif (strcmpi(name,'Results')), enum=ResultsEnum(); return +elseif (strcmpi(name,'Vertices')), enum=VerticesEnum(); return +elseif (strcmpi(name,'SolutionType')), enum=SolutionTypeEnum(); return +elseif (strcmpi(name,'AnalysisType')), enum=AnalysisTypeEnum(); return +elseif (strcmpi(name,'ConfigurationType')), enum=ConfigurationTypeEnum(); return +elseif (strcmpi(name,'SubAnalysisType')), enum=SubAnalysisTypeEnum(); return +elseif (strcmpi(name,'AnalysisCounter')), enum=AnalysisCounterEnum(); return +elseif (strcmpi(name,'DiagnosticSolution')), enum=DiagnosticSolutionEnum(); return +elseif (strcmpi(name,'DiagnosticAnalysis')), enum=DiagnosticAnalysisEnum(); return +elseif (strcmpi(name,'DiagnosticHorizAnalysis')), enum=DiagnosticHorizAnalysisEnum(); return +elseif (strcmpi(name,'DiagnosticVertAnalysis')), enum=DiagnosticVertAnalysisEnum(); return +elseif (strcmpi(name,'DiagnosticHutterAnalysis')), enum=DiagnosticHutterAnalysisEnum(); return +elseif (strcmpi(name,'DiagnosticStokesAnalysis')), enum=DiagnosticStokesAnalysisEnum(); return +elseif (strcmpi(name,'HorizAnalysis')), enum=HorizAnalysisEnum(); return +elseif (strcmpi(name,'HutterAnalysis')), enum=HutterAnalysisEnum(); return +elseif (strcmpi(name,'StokesAnalysis')), enum=StokesAnalysisEnum(); return +elseif (strcmpi(name,'VertAnalysis')), enum=VertAnalysisEnum(); return +elseif (strcmpi(name,'AdjointSolution')), enum=AdjointSolutionEnum(); return +elseif (strcmpi(name,'AdjointHorizAnalysis')), enum=AdjointHorizAnalysisEnum(); return +elseif (strcmpi(name,'AdjointStokesAnalysis')), enum=AdjointStokesAnalysisEnum(); return +elseif (strcmpi(name,'ControlAnalysis')), enum=ControlAnalysisEnum(); return +elseif (strcmpi(name,'GradientAnalysis')), enum=GradientAnalysisEnum(); return +elseif (strcmpi(name,'InverseAnalysis')), enum=InverseAnalysisEnum(); return +elseif (strcmpi(name,'ThermalSolution')), enum=ThermalSolutionEnum(); return +elseif (strcmpi(name,'ThermalAnalysis')), enum=ThermalAnalysisEnum(); return +elseif (strcmpi(name,'Transient2DSolution')), enum=Transient2DSolutionEnum(); return +elseif (strcmpi(name,'Transient2DAnalysis')), enum=Transient2DAnalysisEnum(); return +elseif (strcmpi(name,'Transient3DSolution')), enum=Transient3DSolutionEnum(); return +elseif (strcmpi(name,'Transient3DAnalysis')), enum=Transient3DAnalysisEnum(); return +elseif (strcmpi(name,'SteadyAnalysis')), enum=SteadyAnalysisEnum(); return +elseif (strcmpi(name,'TransientAnalysis')), enum=TransientAnalysisEnum(); return +elseif (strcmpi(name,'BedSlopeSolution')), enum=BedSlopeSolutionEnum(); return +elseif (strcmpi(name,'BedSlopeAnalysis')), enum=BedSlopeAnalysisEnum(); return +elseif (strcmpi(name,'SurfaceSlopeSolution')), enum=SurfaceSlopeSolutionEnum(); return +elseif (strcmpi(name,'SurfaceSlopeAnalysis')), enum=SurfaceSlopeAnalysisEnum(); return +elseif (strcmpi(name,'BedSlopeXAnalysis')), enum=BedSlopeXAnalysisEnum(); return +elseif (strcmpi(name,'BedSlopeYAnalysis')), enum=BedSlopeYAnalysisEnum(); return +elseif (strcmpi(name,'SurfaceSlopeXAnalysis')), enum=SurfaceSlopeXAnalysisEnum(); return +elseif (strcmpi(name,'SurfaceSlopeYAnalysis')), enum=SurfaceSlopeYAnalysisEnum(); return +elseif (strcmpi(name,'BalancedthicknessSolution')), enum=BalancedthicknessSolutionEnum(); return +elseif (strcmpi(name,'BalancedthicknessAnalysis')), enum=BalancedthicknessAnalysisEnum(); return +elseif (strcmpi(name,'BalancedvelocitiesSolution')), enum=BalancedvelocitiesSolutionEnum(); return +elseif (strcmpi(name,'BalancedvelocitiesAnalysis')), enum=BalancedvelocitiesAnalysisEnum(); return +elseif (strcmpi(name,'PrognosticSolution')), enum=PrognosticSolutionEnum(); return +elseif (strcmpi(name,'PrognosticAnalysis')), enum=PrognosticAnalysisEnum(); return +elseif (strcmpi(name,'MeltingAnalysis')), enum=MeltingAnalysisEnum(); return +elseif (strcmpi(name,'ParametersSolution')), enum=ParametersSolutionEnum(); return +elseif (strcmpi(name,'ParametersAnalysis')), enum=ParametersAnalysisEnum(); return +elseif (strcmpi(name,'SteadystateSolution')), enum=SteadystateSolutionEnum(); return +elseif (strcmpi(name,'SteadystateAnalysis')), enum=SteadystateAnalysisEnum(); return +elseif (strcmpi(name,'NoneAnalysis')), enum=NoneAnalysisEnum(); return +elseif (strcmpi(name,'Formulation')), enum=FormulationEnum(); return +elseif (strcmpi(name,'HutterFormulation')), enum=HutterFormulationEnum(); return +elseif (strcmpi(name,'MacAyealFormulation')), enum=MacAyealFormulationEnum(); return +elseif (strcmpi(name,'MacAyealPattynFormulation')), enum=MacAyealPattynFormulationEnum(); return +elseif (strcmpi(name,'NoneFormulation')), enum=NoneFormulationEnum(); return +elseif (strcmpi(name,'PattynFormulation')), enum=PattynFormulationEnum(); return +elseif (strcmpi(name,'StokesFormulation')), enum=StokesFormulationEnum(); return +elseif (strcmpi(name,'Object')), enum=ObjectEnum(); return +elseif (strcmpi(name,'Hook')), enum=HookEnum(); return +elseif (strcmpi(name,'Segment')), enum=SegmentEnum(); return +elseif (strcmpi(name,'Element')), enum=ElementEnum(); return +elseif (strcmpi(name,'DofIndexing')), enum=DofIndexingEnum(); return +elseif (strcmpi(name,'ElementProperties')), enum=ElementPropertiesEnum(); return +elseif (strcmpi(name,'NodeProperties')), enum=NodePropertiesEnum(); return +elseif (strcmpi(name,'Penta')), enum=PentaEnum(); return +elseif (strcmpi(name,'Tria')), enum=TriaEnum(); return +elseif (strcmpi(name,'Node')), enum=NodeEnum(); return +elseif (strcmpi(name,'Vertex')), enum=VertexEnum(); return +elseif (strcmpi(name,'Load')), enum=LoadEnum(); return +elseif (strcmpi(name,'Icefront')), enum=IcefrontEnum(); return +elseif (strcmpi(name,'Numericalflux')), enum=NumericalfluxEnum(); return +elseif (strcmpi(name,'Pengrid')), enum=PengridEnum(); return +elseif (strcmpi(name,'Penpair')), enum=PenpairEnum(); return +elseif (strcmpi(name,'QuadIceFront')), enum=QuadIceFrontEnum(); return +elseif (strcmpi(name,'QuadRiftFront')), enum=QuadRiftFrontEnum(); return +elseif (strcmpi(name,'Riftfront')), enum=RiftfrontEnum(); return +elseif (strcmpi(name,'SegmentIcefront')), enum=SegmentIcefrontEnum(); return +elseif (strcmpi(name,'SegmentRiftfront')), enum=SegmentRiftfrontEnum(); return +elseif (strcmpi(name,'Material')), enum=MaterialEnum(); return +elseif (strcmpi(name,'Matice')), enum=MaticeEnum(); return +elseif (strcmpi(name,'Matpar')), enum=MatparEnum(); return +elseif (strcmpi(name,'Input')), enum=InputEnum(); return +elseif (strcmpi(name,'BoolInput')), enum=BoolInputEnum(); return +elseif (strcmpi(name,'DoubleInput')), enum=DoubleInputEnum(); return +elseif (strcmpi(name,'IntInput')), enum=IntInputEnum(); return +elseif (strcmpi(name,'PentaVertexInput')), enum=PentaVertexInputEnum(); return +elseif (strcmpi(name,'TriaVertexInput')), enum=TriaVertexInputEnum(); return +elseif (strcmpi(name,'Param')), enum=ParamEnum(); return +elseif (strcmpi(name,'BoolParam')), enum=BoolParamEnum(); return +elseif (strcmpi(name,'DoubleMatParam')), enum=DoubleMatParamEnum(); return +elseif (strcmpi(name,'DoubleMatArrayParam')), enum=DoubleMatArrayParamEnum(); return +elseif (strcmpi(name,'DoubleParam')), enum=DoubleParamEnum(); return +elseif (strcmpi(name,'DoubleVecParam')), enum=DoubleVecParamEnum(); return +elseif (strcmpi(name,'IntParam')), enum=IntParamEnum(); return +elseif (strcmpi(name,'FileParam')), enum=FileParamEnum(); return +elseif (strcmpi(name,'PetscMatParam')), enum=PetscMatParamEnum(); return +elseif (strcmpi(name,'PetscVecParam')), enum=PetscVecParamEnum(); return +elseif (strcmpi(name,'StringArrayParam')), enum=StringArrayParamEnum(); return +elseif (strcmpi(name,'StringParam')), enum=StringParamEnum(); return +elseif (strcmpi(name,'ElementResult')), enum=ElementResultEnum(); return +elseif (strcmpi(name,'ExternalResult')), enum=ExternalResultEnum(); return +elseif (strcmpi(name,'Rgb')), enum=RgbEnum(); return +elseif (strcmpi(name,'Spc')), enum=SpcEnum(); return +elseif (strcmpi(name,'Geography')), enum=GeographyEnum(); return +elseif (strcmpi(name,'IceSheet')), enum=IceSheetEnum(); return +elseif (strcmpi(name,'IceShelf')), enum=IceShelfEnum(); return +elseif (strcmpi(name,'Water')), enum=WaterEnum(); return +elseif (strcmpi(name,'Ice')), enum=IceEnum(); return +elseif (strcmpi(name,'Air')), enum=AirEnum(); return +elseif (strcmpi(name,'Melange')), enum=MelangeEnum(); return +elseif (strcmpi(name,'AccumulationRate')), enum=AccumulationRateEnum(); return +elseif (strcmpi(name,'Adjointx')), enum=AdjointxEnum(); return +elseif (strcmpi(name,'Adjointy')), enum=AdjointyEnum(); return +elseif (strcmpi(name,'Adjointz')), enum=AdjointzEnum(); return +elseif (strcmpi(name,'Adjointp')), enum=AdjointpEnum(); return +elseif (strcmpi(name,'ArtDiff')), enum=ArtDiffEnum(); return +elseif (strcmpi(name,'Bed')), enum=BedEnum(); return +elseif (strcmpi(name,'BedSlopeX')), enum=BedSlopeXEnum(); return +elseif (strcmpi(name,'BedSlopeY')), enum=BedSlopeYEnum(); return +elseif (strcmpi(name,'Boundary')), enum=BoundaryEnum(); return +elseif (strcmpi(name,'CmMaxDmpSlope')), enum=CmMaxDmpSlopeEnum(); return +elseif (strcmpi(name,'CmMaxDmpValue')), enum=CmMaxDmpValueEnum(); return +elseif (strcmpi(name,'CmMinDmpSlope')), enum=CmMinDmpSlopeEnum(); return +elseif (strcmpi(name,'CmMinDmpValue')), enum=CmMinDmpValueEnum(); return +elseif (strcmpi(name,'CmNoiseDmp')), enum=CmNoiseDmpEnum(); return +elseif (strcmpi(name,'Collapse')), enum=CollapseEnum(); return +elseif (strcmpi(name,'Constant')), enum=ConstantEnum(); return +elseif (strcmpi(name,'ControlType')), enum=ControlTypeEnum(); return +elseif (strcmpi(name,'Converged')), enum=ConvergedEnum(); return +elseif (strcmpi(name,'DhDt')), enum=DhDtEnum(); return +elseif (strcmpi(name,'DragCoefficient')), enum=DragCoefficientEnum(); return +elseif (strcmpi(name,'DragP')), enum=DragPEnum(); return +elseif (strcmpi(name,'DragQ')), enum=DragQEnum(); return +elseif (strcmpi(name,'DragType')), enum=DragTypeEnum(); return +elseif (strcmpi(name,'Dt')), enum=DtEnum(); return +elseif (strcmpi(name,'ElementOnBed')), enum=ElementOnBedEnum(); return +elseif (strcmpi(name,'ElementOnIceShelf')), enum=ElementOnIceShelfEnum(); return +elseif (strcmpi(name,'ElementOnSurface')), enum=ElementOnSurfaceEnum(); return +elseif (strcmpi(name,'ElementOnWater')), enum=ElementOnWaterEnum(); return +elseif (strcmpi(name,'EpsVel')), enum=EpsVelEnum(); return +elseif (strcmpi(name,'Fill')), enum=FillEnum(); return +elseif (strcmpi(name,'Fit')), enum=FitEnum(); return +elseif (strcmpi(name,'FractionIncrement')), enum=FractionIncrementEnum(); return +elseif (strcmpi(name,'Friction')), enum=FrictionEnum(); return +elseif (strcmpi(name,'GeothermalFlux')), enum=GeothermalFluxEnum(); return +elseif (strcmpi(name,'Internal')), enum=InternalEnum(); return +elseif (strcmpi(name,'Kflag')), enum=KflagEnum(); return +elseif (strcmpi(name,'MassFlux')), enum=MassFluxEnum(); return +elseif (strcmpi(name,'MaxPenetration')), enum=MaxPenetrationEnum(); return +elseif (strcmpi(name,'MeanVel')), enum=MeanVelEnum(); return +elseif (strcmpi(name,'MeltingOffset')), enum=MeltingOffsetEnum(); return +elseif (strcmpi(name,'MeltingRate')), enum=MeltingRateEnum(); return +elseif (strcmpi(name,'Misfit')), enum=MisfitEnum(); return +elseif (strcmpi(name,'NodeOnBed')), enum=NodeOnBedEnum(); return +elseif (strcmpi(name,'NodeOnIceSheet')), enum=NodeOnIceSheetEnum(); return +elseif (strcmpi(name,'NodeOnIceShelf')), enum=NodeOnIceShelfEnum(); return +elseif (strcmpi(name,'NodeOnSurface')), enum=NodeOnSurfaceEnum(); return +elseif (strcmpi(name,'NumberNodeToElementConnectivity')), enum=NumberNodeToElementConnectivityEnum(); return +elseif (strcmpi(name,'PenaltyOffset')), enum=PenaltyOffsetEnum(); return +elseif (strcmpi(name,'Pflag')), enum=PflagEnum(); return +elseif (strcmpi(name,'Pressure')), enum=PressureEnum(); return +elseif (strcmpi(name,'PressureOld')), enum=PressureOldEnum(); return +elseif (strcmpi(name,'QmuPressure')), enum=QmuPressureEnum(); return +elseif (strcmpi(name,'ResetPenalties')), enum=ResetPenaltiesEnum(); return +elseif (strcmpi(name,'RheologyB')), enum=RheologyBEnum(); return +elseif (strcmpi(name,'RheologyB2d')), enum=RheologyB2dEnum(); return +elseif (strcmpi(name,'RheologyN')), enum=RheologyNEnum(); return +elseif (strcmpi(name,'SegmentOnIceShelf')), enum=SegmentOnIceShelfEnum(); return +elseif (strcmpi(name,'StabilizeConstraints')), enum=StabilizeConstraintsEnum(); return +elseif (strcmpi(name,'StokesReconditioning')), enum=StokesReconditioningEnum(); return +elseif (strcmpi(name,'SurfaceArea')), enum=SurfaceAreaEnum(); return +elseif (strcmpi(name,'Surface')), enum=SurfaceEnum(); return +elseif (strcmpi(name,'SurfaceSlopeX')), enum=SurfaceSlopeXEnum(); return +elseif (strcmpi(name,'SurfaceSlopeY')), enum=SurfaceSlopeYEnum(); return +elseif (strcmpi(name,'Temperature')), enum=TemperatureEnum(); return +elseif (strcmpi(name,'TemperatureOld')), enum=TemperatureOldEnum(); return +elseif (strcmpi(name,'Thickness')), enum=ThicknessEnum(); return +elseif (strcmpi(name,'Type')), enum=TypeEnum(); return +elseif (strcmpi(name,'Vel')), enum=VelEnum(); return +elseif (strcmpi(name,'VelObs')), enum=VelObsEnum(); return +elseif (strcmpi(name,'ViscosityOvershoot')), enum=ViscosityOvershootEnum(); return +elseif (strcmpi(name,'VxAverage')), enum=VxAverageEnum(); return +elseif (strcmpi(name,'Vx')), enum=VxEnum(); return +elseif (strcmpi(name,'VxObs')), enum=VxObsEnum(); return +elseif (strcmpi(name,'VxOld')), enum=VxOldEnum(); return +elseif (strcmpi(name,'QmuVx')), enum=QmuVxEnum(); return +elseif (strcmpi(name,'VyAverage')), enum=VyAverageEnum(); return +elseif (strcmpi(name,'Vy')), enum=VyEnum(); return +elseif (strcmpi(name,'VyObs')), enum=VyObsEnum(); return +elseif (strcmpi(name,'VyOld')), enum=VyOldEnum(); return +elseif (strcmpi(name,'QmuVy')), enum=QmuVyEnum(); return +elseif (strcmpi(name,'VzAverage')), enum=VzAverageEnum(); return +elseif (strcmpi(name,'Vz')), enum=VzEnum(); return +elseif (strcmpi(name,'VzObs')), enum=VzObsEnum(); return +elseif (strcmpi(name,'VzOld')), enum=VzOldEnum(); return +elseif (strcmpi(name,'QmuVz')), enum=QmuVzEnum(); return +elseif (strcmpi(name,'Weights')), enum=WeightsEnum(); return +elseif (strcmpi(name,'P0')), enum=P0Enum(); return +elseif (strcmpi(name,'P1')), enum=P1Enum(); return +elseif (strcmpi(name,'P1DG')), enum=P1DGEnum(); return +elseif (strcmpi(name,'Mini')), enum=MiniEnum(); return +elseif (strcmpi(name,'DoubleElementResult')), enum=DoubleElementResultEnum(); return +elseif (strcmpi(name,'TriaVertexElementResult')), enum=TriaVertexElementResultEnum(); return +elseif (strcmpi(name,'PentaVertexElementResult')), enum=PentaVertexElementResultEnum(); return +elseif (strcmpi(name,'BoolExternalResult')), enum=BoolExternalResultEnum(); return +elseif (strcmpi(name,'DoubleExternalResult')), enum=DoubleExternalResultEnum(); return +elseif (strcmpi(name,'DoubleVecExternalResult')), enum=DoubleVecExternalResultEnum(); return +elseif (strcmpi(name,'DoubleMatExternalResult')), enum=DoubleMatExternalResultEnum(); return +elseif (strcmpi(name,'IntExternalResult')), enum=IntExternalResultEnum(); return +elseif (strcmpi(name,'PetscVecExternalResult')), enum=PetscVecExternalResultEnum(); return +elseif (strcmpi(name,'StringExternalResult')), enum=StringExternalResultEnum(); return +elseif (strcmpi(name,'J')), enum=JEnum(); return +elseif (strcmpi(name,'Patch')), enum=PatchEnum(); return +elseif (strcmpi(name,'PatchVertices')), enum=PatchVerticesEnum(); return +elseif (strcmpi(name,'PatchNodes')), enum=PatchNodesEnum(); return +elseif (strcmpi(name,'Time')), enum=TimeEnum(); return +elseif (strcmpi(name,'Relative')), enum=RelativeEnum(); return +elseif (strcmpi(name,'Residual')), enum=ResidualEnum(); return +elseif (strcmpi(name,'Absolute')), enum=AbsoluteEnum(); return +elseif (strcmpi(name,'RhoIce')), enum=RhoIceEnum(); return +elseif (strcmpi(name,'RhoWater')), enum=RhoWaterEnum(); return +elseif (strcmpi(name,'Gravity')), enum=GravityEnum(); return +elseif (strcmpi(name,'ThermalConductivity')), enum=ThermalConductivityEnum(); return +elseif (strcmpi(name,'MixedLayerCapacity')), enum=MixedLayerCapacityEnum(); return +elseif (strcmpi(name,'ThermalExchangeVelocity')), enum=ThermalExchangeVelocityEnum(); return +elseif (strcmpi(name,'Intersect')), enum=IntersectEnum(); return +elseif (strcmpi(name,'Colinear')), enum=ColinearEnum(); return +elseif (strcmpi(name,'Separate')), enum=SeparateEnum(); return +elseif (strcmpi(name,'Beta')), enum=BetaEnum(); return +elseif (strcmpi(name,'CmGradient')), enum=CmGradientEnum(); return +elseif (strcmpi(name,'CmJump')), enum=CmJumpEnum(); return +elseif (strcmpi(name,'CmMax')), enum=CmMaxEnum(); return +elseif (strcmpi(name,'CmMin')), enum=CmMinEnum(); return +elseif (strcmpi(name,'Adjoint')), enum=AdjointEnum(); return +elseif (strcmpi(name,'Gradient')), enum=GradientEnum(); return +elseif (strcmpi(name,'OldGradient')), enum=OldGradientEnum(); return +elseif (strcmpi(name,'Connectivity')), enum=ConnectivityEnum(); return +elseif (strcmpi(name,'ControlParameter')), enum=ControlParameterEnum(); return +elseif (strcmpi(name,'ControlSteady')), enum=ControlSteadyEnum(); return +elseif (strcmpi(name,'DakotaParameter')), enum=DakotaParameterEnum(); return +elseif (strcmpi(name,'Dim')), enum=DimEnum(); return +elseif (strcmpi(name,'EpsAbs')), enum=EpsAbsEnum(); return +elseif (strcmpi(name,'EpsCm')), enum=EpsCmEnum(); return +elseif (strcmpi(name,'EpsRel')), enum=EpsRelEnum(); return +elseif (strcmpi(name,'EpsRes')), enum=EpsResEnum(); return +elseif (strcmpi(name,'HeatCapacity')), enum=HeatCapacityEnum(); return +elseif (strcmpi(name,'IsHutter')), enum=IsHutterEnum(); return +elseif (strcmpi(name,'IsMacAyealPattyn')), enum=IsMacAyealPattynEnum(); return +elseif (strcmpi(name,'IsStokes')), enum=IsStokesEnum(); return +elseif (strcmpi(name,'LatentHeat')), enum=LatentHeatEnum(); return +elseif (strcmpi(name,'Lowmem')), enum=LowmemEnum(); return +elseif (strcmpi(name,'MaxIter')), enum=MaxIterEnum(); return +elseif (strcmpi(name,'MaxNonlinearIterations')), enum=MaxNonlinearIterationsEnum(); return +elseif (strcmpi(name,'MeltingPoint')), enum=MeltingPointEnum(); return +elseif (strcmpi(name,'MinMechanicalConstraints')), enum=MinMechanicalConstraintsEnum(); return +elseif (strcmpi(name,'MinThermalConstraints')), enum=MinThermalConstraintsEnum(); return +elseif (strcmpi(name,'NSteps')), enum=NStepsEnum(); return +elseif (strcmpi(name,'Ndt')), enum=NdtEnum(); return +elseif (strcmpi(name,'NumOutput')), enum=NumOutputEnum(); return +elseif (strcmpi(name,'NumRifts')), enum=NumRiftsEnum(); return +elseif (strcmpi(name,'NumberOfDofsPerNode')), enum=NumberOfDofsPerNodeEnum(); return +elseif (strcmpi(name,'NumberOfElements')), enum=NumberOfElementsEnum(); return +elseif (strcmpi(name,'NumberOfNodes')), enum=NumberOfNodesEnum(); return +elseif (strcmpi(name,'NumberOfVertices')), enum=NumberOfVerticesEnum(); return +elseif (strcmpi(name,'OptScal')), enum=OptScalEnum(); return +elseif (strcmpi(name,'OutputFilePointer')), enum=OutputFilePointerEnum(); return +elseif (strcmpi(name,'ParameterOutput')), enum=ParameterOutputEnum(); return +elseif (strcmpi(name,'PenaltyMelting')), enum=PenaltyMeltingEnum(); return +elseif (strcmpi(name,'QmuAnalysis')), enum=QmuAnalysisEnum(); return +elseif (strcmpi(name,'QmuErrName')), enum=QmuErrNameEnum(); return +elseif (strcmpi(name,'QmuInName')), enum=QmuInNameEnum(); return +elseif (strcmpi(name,'QmuMassFluxSegments')), enum=QmuMassFluxSegmentsEnum(); return +elseif (strcmpi(name,'QmuNPart')), enum=QmuNPartEnum(); return +elseif (strcmpi(name,'QmuOutName')), enum=QmuOutNameEnum(); return +elseif (strcmpi(name,'QmuPart')), enum=QmuPartEnum(); return +elseif (strcmpi(name,'ResponseDescriptors')), enum=ResponseDescriptorsEnum(); return +elseif (strcmpi(name,'SolverString')), enum=SolverStringEnum(); return +elseif (strcmpi(name,'Sparsity')), enum=SparsityEnum(); return +elseif (strcmpi(name,'TolX')), enum=TolXEnum(); return +elseif (strcmpi(name,'VariableDescriptors')), enum=VariableDescriptorsEnum(); return +elseif (strcmpi(name,'Verbose')), enum=VerboseEnum(); return +elseif (strcmpi(name,'WaitOnLock')), enum=WaitOnLockEnum(); return +elseif (strcmpi(name,'Yts')), enum=YtsEnum(); return +else error(['Enum ' name ' not found']); + +end Index: /issm/trunk/src/m/solutions/MatlabProcessPatch.m =================================================================== --- /issm/trunk/src/m/solutions/MatlabProcessPatch.m (revision 5102) +++ /issm/trunk/src/m/solutions/MatlabProcessPatch.m (revision 5103) @@ -38,5 +38,5 @@ %get name - fieldname=EnumAsString(fields(i)); + fieldname=EnumToString(fields(i)); %get line positions Index: /issm/trunk/src/m/solutions/NewFemModel.m =================================================================== --- /issm/trunk/src/m/solutions/NewFemModel.m (revision 5102) +++ /issm/trunk/src/m/solutions/NewFemModel.m (revision 5103) @@ -28,5 +28,5 @@ analysis_type=femmodel.analysis_type_list(i); - displaystring(md.verbose,'%s%s',' dealing with analysis type: ',EnumAsString(analysis_type)); + displaystring(md.verbose,'%s%s',' dealing with analysis type: ',EnumToString(analysis_type)); femmodel=SetCurrentConfiguration(femmodel,analysis_type); Index: /issm/trunk/src/m/solutions/SolutionConfiguration.m =================================================================== --- /issm/trunk/src/m/solutions/SolutionConfiguration.m (revision 5102) +++ /issm/trunk/src/m/solutions/SolutionConfiguration.m (revision 5103) @@ -58,5 +58,5 @@ otherwise - error('%s%s%s',' solution type: ',EnumAsString(solutiontype),' not supported yet!'); + error('%s%s%s',' solution type: ',EnumToString(solutiontype),' not supported yet!'); end Index: /issm/trunk/src/m/solutions/issm.m =================================================================== --- /issm/trunk/src/m/solutions/issm.m (revision 5102) +++ /issm/trunk/src/m/solutions/issm.m (revision 5103) @@ -34,5 +34,5 @@ displaystring(verbose,'%s',['write results']) - md.results.(EnumAsString(solution_type))=OutputResults(femmodel.elements, femmodel.nodes , femmodel.vertices , femmodel.loads , femmodel.materials, femmodel.parameters, femmodel.results); + md.results.(EnumToString(solution_type))=OutputResults(femmodel.elements, femmodel.nodes , femmodel.vertices , femmodel.loads , femmodel.materials, femmodel.parameters, femmodel.results); else %launch dakota driver for diagnostic core solution Index: /issm/trunk/src/mex/InputUpdateFromVector/InputUpdateFromVector.cpp =================================================================== --- /issm/trunk/src/mex/InputUpdateFromVector/InputUpdateFromVector.cpp (revision 5102) +++ /issm/trunk/src/mex/InputUpdateFromVector/InputUpdateFromVector.cpp (revision 5103) @@ -38,5 +38,5 @@ /*Check that type is one of Constant, Vertex or Element: */ if ((TypeEnum!=ConstantEnum) && (TypeEnum!=VertexEnum) && (TypeEnum!=ElementEnum)){ - ISSMERROR("%s%s%s\n","Type of input can only be a constant, a vertex or an element vector. Right now, you input a ",EnumAsString(TypeEnum)," type data for input update"); + ISSMERROR("%s%s%s\n","Type of input can only be a constant, a vertex or an element vector. Right now, you input a ",EnumToString(TypeEnum)," type data for input update"); }