Index: /issm/trunk/src/c/Container/DataSet.cpp =================================================================== --- /issm/trunk/src/c/Container/DataSet.cpp (revision 8223) +++ /issm/trunk/src/c/Container/DataSet.cpp (revision 8224) @@ -123,5 +123,5 @@ * because this is a nasty error: */ if (marshalled_dataset!=old_marshalled_dataset){ - _error_("final marshalled dataset \"%s\" is different from initial one!",EnumToString(enum_type)); + _error_("final marshalled dataset \"%s\" is different from initial one!",EnumToStringx(enum_type)); abort(); } @@ -355,5 +355,5 @@ break; default: - _error_("could not recognize enum type: %i (%s)",enum_type,EnumToString(enum_type)); + _error_("could not recognize enum type: %i (%s)",enum_type,EnumToStringx(enum_type)); } @@ -479,5 +479,5 @@ /*Carry out a binary search on the sorted_ids: */ if(!binary_search(&id_offset,eid, sorted_ids,objects.size())){ - _error_("could not find object with id %i in DataSet %s",eid,EnumToString(enum_type)); + _error_("could not find object with id %i in DataSet %s",eid,EnumToStringx(enum_type)); } Index: /issm/trunk/src/c/Container/Inputs.cpp =================================================================== --- /issm/trunk/src/c/Container/Inputs.cpp (revision 8223) +++ /issm/trunk/src/c/Container/Inputs.cpp (revision 8224) @@ -63,5 +63,5 @@ /*we could not find an input with the correct enum type. No defaults values were provided, * error out: */ - _error_("could not find input with enum type %i (%s)",enum_type,EnumToString(enum_type)); + _error_("could not find input with enum type %i (%s)",enum_type,EnumToStringx(enum_type)); } @@ -91,5 +91,5 @@ /*we could not find an input with the correct enum type. No defaults values were provided, * error out: */ - _error_("could not find input with enum type %i (%s)",enum_type,EnumToString(enum_type)); + _error_("could not find input with enum type %i (%s)",enum_type,EnumToStringx(enum_type)); } @@ -119,5 +119,5 @@ /*we could not find an input with the correct enum type. No defaults values were provided, * error out: */ - _error_("could not find input with enum type %i (%s)",enum_type,EnumToString(enum_type)); + _error_("could not find input with enum type %i (%s)",enum_type,EnumToStringx(enum_type)); } @@ -147,5 +147,5 @@ /*we could not find an input with the correct enum type. No defaults values were provided, * error out: */ - _error_("could not find input with enum type %i (%s)",enum_type,EnumToString(enum_type)); + _error_("could not find input with enum type %i (%s)",enum_type,EnumToStringx(enum_type)); } @@ -219,5 +219,5 @@ /*some checks: */ - if(!constrain_input) _error_(" input %s could not be found!",EnumToString(constrain_enum)); + if(!constrain_input) _error_(" input %s could not be found!",EnumToStringx(constrain_enum)); /*Apply ContrainMin: */ @@ -260,5 +260,5 @@ } else{ - _error_("Input %s not found",EnumToString(enumtype)); + _error_("Input %s not found",EnumToStringx(enumtype)); } @@ -281,5 +281,5 @@ } else{ - _error_("Input %s not found",EnumToString(enumtype)); + _error_("Input %s not found",EnumToStringx(enumtype)); } @@ -302,5 +302,5 @@ } else{ - _error_("Input %s not found",EnumToString(enumtype)); + _error_("Input %s not found",EnumToStringx(enumtype)); } @@ -323,5 +323,5 @@ } else{ - _error_("Input %s not found",EnumToString(enumtype)); + _error_("Input %s not found",EnumToStringx(enumtype)); } @@ -375,5 +375,5 @@ /*Make a copy of the original input: */ original=(Input*)this->GetInput(original_enum); - if(!original)_error_("could not find input with enum: %s",EnumToString(original_enum)); + if(!original)_error_("could not find input with enum: %s",EnumToStringx(original_enum)); copy=(Input*)original->copy(); @@ -422,6 +422,6 @@ /*some checks: */ - if(!xinput) _error_(" input %s could not be found!",EnumToString(XEnum)); - if(!yinput) _error_(" input %s could not be found!",EnumToString(YEnum)); + if(!xinput) _error_(" input %s could not be found!",EnumToStringx(XEnum)); + if(!yinput) _error_(" input %s could not be found!",EnumToStringx(YEnum)); /*Apply AXPY: */ Index: /issm/trunk/src/c/Container/Nodes.cpp =================================================================== --- /issm/trunk/src/c/Container/Nodes.cpp (revision 8223) +++ /issm/trunk/src/c/Container/Nodes.cpp (revision 8224) @@ -74,5 +74,5 @@ /*some check: */ - if ((setenum!=GsetEnum) && (setenum!=FsetEnum) && (setenum!=SsetEnum))_error_("%s%s%s"," dof distribution for set of enum type ",EnumToString(setenum)," not supported yet!"); + if ((setenum!=GsetEnum) && (setenum!=FsetEnum) && (setenum!=SsetEnum))_error_("%s%s%s"," dof distribution for set of enum type ",EnumToStringx(setenum)," not supported yet!"); /*Go through objects, and distribute dofs locally, from 0 to numberofdofs: */ Index: /issm/trunk/src/c/Container/Options.cpp =================================================================== --- /issm/trunk/src/c/Container/Options.cpp (revision 8223) +++ /issm/trunk/src/c/Container/Options.cpp (revision 8224) @@ -266,5 +266,5 @@ /*Else: not supported*/ else{ - _error_("Cannot recover field \"%s\" for an option of type %s",name,EnumToString(option->Enum())); + _error_("Cannot recover field \"%s\" for an option of type %s",name,EnumToStringx(option->Enum())); } } Index: /issm/trunk/src/c/Container/Results.cpp =================================================================== --- /issm/trunk/src/c/Container/Results.cpp (revision 8223) +++ /issm/trunk/src/c/Container/Results.cpp (revision 8224) @@ -129,5 +129,5 @@ for(i=0;i0){ - fnames[count]=EnumToString(enums[i]); + fnames[count]=EnumToStringx(enums[i]); count++; } Index: /issm/trunk/src/c/EnumDefinitions/EnumDefinitions.h =================================================================== --- /issm/trunk/src/c/EnumDefinitions/EnumDefinitions.h (revision 8223) +++ /issm/trunk/src/c/EnumDefinitions/EnumDefinitions.h (revision 8224) @@ -6,4 +6,7 @@ #ifndef _ENUM_DEFINITIONS_ #define _ENUM_DEFINITIONS_ + +#include "../modules/EnumToStringx/EnumToStringx.h" +#include "../modules/StringToEnumx/StringToEnumx.h" enum definitions{ @@ -444,6 +447,4 @@ /*Functions on enums: */ -char *EnumToString(int enum_type); -int StringToEnum(char *string); char *EnumToModelField(int en); Index: /issm/trunk/src/c/EnumDefinitions/EnumToModelField.cpp =================================================================== --- /issm/trunk/src/c/EnumDefinitions/EnumToModelField.cpp (revision 8223) +++ /issm/trunk/src/c/EnumDefinitions/EnumToModelField.cpp (revision 8224) @@ -23,5 +23,5 @@ case VyObsEnum : return "vy_obs"; case GroundingLineMigrationEnum : return "gl_migration"; - default : _error_("No model field is associated to enum %s",EnumToString(en)); + default : _error_("No model field is associated to enum %s",EnumToStringx(en)); } } Index: /issm/trunk/src/c/EnumDefinitions/README =================================================================== --- /issm/trunk/src/c/EnumDefinitions/README (revision 8223) +++ /issm/trunk/src/c/EnumDefinitions/README (revision 8224) @@ -1,6 +1,6 @@ DO NOT MODIFY the following files: -- StringToEnum.cpp -- EnumToString.cpp +- StringToEnumx.cpp +- EnumToStringx.cpp - src/m/enum/* all these files are automatically synchronized with EnumDefinitions.h and EnumToModelField.cpp Index: /issm/trunk/src/c/EnumDefinitions/Synchronize.sh =================================================================== --- /issm/trunk/src/c/EnumDefinitions/Synchronize.sh (revision 8223) +++ /issm/trunk/src/c/EnumDefinitions/Synchronize.sh (revision 8224) @@ -1,15 +1,16 @@ #!/bin/bash -#Synchronize EnumToString.cpp and StringToEnum.cpp +#Synchronize EnumToStringx.cpp and StringToEnumx.cpp and matlab 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 "[a-zA-Z]Enum" | grep -v include | sed -e "s/,//g" | awk '{ printf "%s %s\n", NR, $0 }' > temp -#first remove existing files -rm EnumToString.cpp StringToEnum.cpp +#Removed existing files rm $ISSM_TIER/src/m/enum/*.m - -echo "Synchronizing Enums..." +rm $ISSM_TIER/src/c/modules/EnumToStringx/EnumToStringx.cpp +rm $ISSM_TIER/src/c/modules/StringToEnumx/StringToEnumx.cpp #Take care of EnumToModelField.m first (easy) #Build EnumToModelField.m {{{1 -cat < EnumToModelField.m +cat < $ISSM_TIER/src/m/enum/EnumToModelField.m function string=EnumToModelField(enum) %ENUMTOMODELFIELD - output string of model field associated to enum @@ -35,10 +36,8 @@ #}}} -#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 "[a-zA-Z]Enum" | grep -v StringToEnum | sed -e "s/,//g" | awk '{ printf "%s %s\n", NR, $0 }' > temp -#Build header of EnumToString.cpp {{{1 -cat < EnumToString.cpp +#Build header of EnumToStringx.cpp {{{1 +cat < $ISSM_TIER/src/c/modules/EnumToStringx/EnumToStringx.cpp /* -* \file EnumToString.cpp: +* \file EnumToStringx.cpp: * \brief: output string associated with enum * @@ -48,9 +47,9 @@ */ -#include "../shared/shared.h" -#include "../include/include.h" -#include "./EnumDefinitions.h" +#include "../../shared/shared.h" +#include "../../include/include.h" +#include "./EnumToStringx.h" -char* EnumToString(int en){ +char* EnumToStringx(int en){ switch(en){ @@ -58,8 +57,8 @@ END #}}} -#Build header of StringToEnum.cpp {{{1 -cat < StringToEnum.cpp +#Build header of StringToEnumx.cpp {{{1 +cat < $ISSM_TIER/src/c/modules/StringToEnumx/StringToEnumx.cpp /* -* \file StringToEnum.cpp: +* \file StringToEnumx.cpp: * \brief: output enum associated with string * @@ -69,39 +68,9 @@ */ -#include "../shared/shared.h" -#include "../include/include.h" -#include "./EnumDefinitions.h" +#include "../../shared/shared.h" +#include "../../include/include.h" +#include "./StringToEnumx.h" -int StringToEnum(char* name){ - -END -#}}} -#Build header of EnumToString.m {{{1 -cat < EnumToString.m -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/EnumDefinitions/Synchronize.sh -% Please read src/c/EnumDefinitions/README for more information -% -% Usage: -% string=EnumToString(enum) - -switch enum, - -END -#}}} -#Build header of StringToEnum.m {{{1 -cat < StringToEnum.m -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/EnumDefinitions/Synchronize.sh -% Please read src/c/EnumDefinitions/README for more information -% -% Usage: -% enum=StringToEnum(name) +int StringToEnumx(char* name){ END @@ -150,21 +119,20 @@ % macro=$NAMEENUM() -macro=$ENUM; +macro=StringToEnum('$NAME'); END #}}} - - #Add case to EnumToString.cpp {{{ - cat <> EnumToString.cpp + #Add case to EnumToStringx.cpp {{{ + cat <> $ISSM_TIER/src/c/modules/EnumToStringx/EnumToStringx.cpp case $NAMEENUM : return "$NAME"; END #}}} - #Add case to StringToEnum.cpp {{{ + #Add case to StringToEnumx.cpp {{{ if [ $i -eq 1 ] then - cat <> StringToEnum.cpp + cat <> $ISSM_TIER/src/c/modules/StringToEnumx/StringToEnumx.cpp if (strcmp(name,"$NAME")==0) return $NAMEENUM; END else - cat <> StringToEnum.cpp + cat <> $ISSM_TIER/src/c/modules/StringToEnumx/StringToEnumx.cpp else if (strcmp(name,"$NAME")==0) return $NAMEENUM; END @@ -172,26 +140,8 @@ #}}} -#Add case to EnumToString.m {{{ -cat <> EnumToString.m -case $NAMEENUM(), string='$NAME'; return -END -#}}} - #Add case to StringToEnum.m {{{ - if [ $i -eq 1 ] - then - cat <> StringToEnum.m - if (strcmpi(name,'$NAME')), enum=$NAMEENUM(); return -END - else - cat <> StringToEnum.m - elseif (strcmpi(name,'$NAME')), enum=$NAMEENUM(); return -END - fi - #}}} - done -#Add footer of of EnumToString.cpp{{{1 -cat <> EnumToString.cpp +#Add footer of of EnumToStringx.cpp{{{1 +cat <> $ISSM_TIER/src/c/modules/EnumToStringx/EnumToStringx.cpp default : return "unknown"; @@ -200,6 +150,6 @@ END #}}} -#Add footer of of StringToEnum.cpp{{{1 -cat <> StringToEnum.cpp +#Add footer of of StringToEnumx.cpp{{{1 +cat <> $ISSM_TIER/src/c/modules/StringToEnumx/StringToEnumx.cpp else _error_("Enum %s not found",name); @@ -207,24 +157,5 @@ END #}}} -#Add footer of of EnumToString.m{{{1 -cat <> EnumToString.m -otherwise, error(['Enum ' num2str(enum) ' not found']); -end -END -#}}} -#Add footer of of StringToEnum.m{{{1 -cat <> StringToEnum.m -else error(['Enum ' name ' not found']); - - end -END -#}}} - -#move files to new location {{{1 -mv StringToEnum.m $ISSM_TIER/src/m/enum/ -mv EnumToString.m $ISSM_TIER/src/m/enum/ -mv EnumToModelField.m $ISSM_TIER/src/m/enum/ -#}}} #clean up{{{ rm temp Index: /issm/trunk/src/c/Makefile.am =================================================================== --- /issm/trunk/src/c/Makefile.am (revision 8223) +++ /issm/trunk/src/c/Makefile.am (revision 8224) @@ -398,6 +398,4 @@ ./io/pfclose.cpp\ ./EnumDefinitions/EnumDefinitions.h\ - ./EnumDefinitions/EnumToString.cpp\ - ./EnumDefinitions/StringToEnum.cpp\ ./EnumDefinitions/EnumToModelField.cpp\ ./modules/AddExternalResultx/AddExternalResultx.h\ @@ -612,4 +610,8 @@ ./modules/ElementConnectivityx/ElementConnectivityx.cpp\ ./modules/ElementConnectivityx/ElementConnectivityx.h\ + ./modules/EnumToStringx/EnumToStringx.cpp\ + ./modules/EnumToStringx/EnumToStringx.h\ + ./modules/StringToEnumx/StringToEnumx.cpp\ + ./modules/StringToEnumx/StringToEnumx.h\ ./modules/MassFluxx/MassFluxx.cpp\ ./modules/MassFluxx/MassFluxx.h\ @@ -1035,6 +1037,4 @@ ./io/ParsePetscOptions.cpp\ ./EnumDefinitions/EnumDefinitions.h\ - ./EnumDefinitions/EnumToString.cpp\ - ./EnumDefinitions/StringToEnum.cpp\ ./EnumDefinitions/EnumToModelField.cpp\ ./modules/AddExternalResultx/AddExternalResultx.h\ @@ -1240,4 +1240,8 @@ ./modules/Reduceloadx/Reduceloadx.h\ ./modules/Reduceloadx/Reduceloadx.cpp\ + ./modules/EnumToStringx/EnumToStringx.cpp\ + ./modules/EnumToStringx/EnumToStringx.h\ + ./modules/StringToEnumx/StringToEnumx.cpp\ + ./modules/StringToEnumx/StringToEnumx.h\ ./modules/MassFluxx/MassFluxx.cpp\ ./modules/MassFluxx/MassFluxx.h\ Index: /issm/trunk/src/c/io/FetchParams.cpp =================================================================== --- /issm/trunk/src/c/io/FetchParams.cpp (revision 8223) +++ /issm/trunk/src/c/io/FetchParams.cpp (revision 8224) @@ -53,5 +53,5 @@ /*Get i'th field: */ name=(char*)mxGetFieldNameByNumber(dataref,count); - enum_type=StringToEnum(name); + enum_type=StringToEnumx(name); pfield=mxGetFieldByNumber(dataref,0,count); _assert_(pfield); Index: /issm/trunk/src/c/io/ParsePetscOptions.cpp =================================================================== --- /issm/trunk/src/c/io/ParsePetscOptions.cpp (revision 8223) +++ /issm/trunk/src/c/io/ParsePetscOptions.cpp (revision 8224) @@ -63,5 +63,5 @@ if (line[0]=='+'){ /*this is the analysis line: */ - analyses[numanalyses]=StringToEnum(&line[1]); //skip the '+' + analyses[numanalyses]=StringToEnumx(&line[1]); //skip the '+' numanalyses++; } Index: /issm/trunk/src/c/modules/CostFunctionx/CostFunctionx.cpp =================================================================== --- /issm/trunk/src/c/modules/CostFunctionx/CostFunctionx.cpp (revision 8223) +++ /issm/trunk/src/c/modules/CostFunctionx/CostFunctionx.cpp (revision 8224) @@ -25,5 +25,5 @@ /*Get response*/ - Responsex(&J,elements,nodes,vertices,loads,materials,parameters,EnumToString(response),false); //False means DO NOT process units + Responsex(&J,elements,nodes,vertices,loads,materials,parameters,EnumToStringx(response),false); //False means DO NOT process units /*Add Regularization terms: */ Index: /issm/trunk/src/c/modules/DakotaResponsesx/DakotaResponsesx.cpp =================================================================== --- /issm/trunk/src/c/modules/DakotaResponsesx/DakotaResponsesx.cpp (revision 8223) +++ /issm/trunk/src/c/modules/DakotaResponsesx/DakotaResponsesx.cpp (revision 8224) @@ -51,5 +51,5 @@ /*this response was scaled. pick up the response from the inputs: */ - GetVectorFromInputsx(&vertex_response,elements,nodes, vertices, loads, materials, parameters, StringToEnum(root),VertexEnum); + GetVectorFromInputsx(&vertex_response,elements,nodes, vertices, loads, materials, parameters, StringToEnumx(root),VertexEnum); /*Now, average it onto the partition grids: */ Index: /issm/trunk/src/c/modules/EnumToStringx/EnumToStringx.cpp =================================================================== --- /issm/trunk/src/c/modules/EnumToStringx/EnumToStringx.cpp (revision 8224) +++ /issm/trunk/src/c/modules/EnumToStringx/EnumToStringx.cpp (revision 8224) @@ -0,0 +1,392 @@ +/* +* \file EnumToStringx.cpp: +* \brief: output string associated with enum +* +* WARNING: DO NOT MODIFY THIS FILE +* this file has been automatically generated by Synchronize.sh +* Please read README for more information +*/ + +#include "../../shared/shared.h" +#include "../../include/include.h" +#include "./EnumToStringx.h" + +char* EnumToStringx(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 AnalysisCounterEnum : return "AnalysisCounter"; + case DiagnosticSolutionEnum : return "DiagnosticSolution"; + case DiagnosticAnalysisEnum : return "DiagnosticAnalysis"; + case DiagnosticHorizAnalysisEnum : return "DiagnosticHorizAnalysis"; + case DiagnosticVertAnalysisEnum : return "DiagnosticVertAnalysis"; + case DiagnosticHutterAnalysisEnum : return "DiagnosticHutterAnalysis"; + case AdjointSolutionEnum : return "AdjointSolution"; + case AdjointHorizAnalysisEnum : return "AdjointHorizAnalysis"; + case AdjointBalancedthicknessAnalysisEnum : return "AdjointBalancedthicknessAnalysis"; + case ControlAnalysisEnum : return "ControlAnalysis"; + case GradientAnalysisEnum : return "GradientAnalysis"; + case InverseAnalysisEnum : return "InverseAnalysis"; + case ThermalSolutionEnum : return "ThermalSolution"; + case ThermalAnalysisEnum : return "ThermalAnalysis"; + case HydrologySolutionEnum : return "HydrologySolution"; + case HydrologyAnalysisEnum : return "HydrologyAnalysis"; + case Transient2DSolutionEnum : return "Transient2DSolution"; + case Transient2DAnalysisEnum : return "Transient2DAnalysis"; + case Transient3DSolutionEnum : return "Transient3DSolution"; + case Transient3DAnalysisEnum : return "Transient3DAnalysis"; + case GroundingLineMigration2DSolutionEnum : return "GroundingLineMigration2DSolution"; + 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 FlaimSolutionEnum : return "FlaimSolution"; + case FlaimAnalysisEnum : return "FlaimAnalysis"; + case NoneAnalysisEnum : return "NoneAnalysis"; + case ApproximationEnum : return "Approximation"; + case HutterApproximationEnum : return "HutterApproximation"; + case MacAyealApproximationEnum : return "MacAyealApproximation"; + case MacAyealPattynApproximationEnum : return "MacAyealPattynApproximation"; + case MacAyealStokesApproximationEnum : return "MacAyealStokesApproximation"; + case NoneApproximationEnum : return "NoneApproximation"; + case PattynApproximationEnum : return "PattynApproximation"; + case PattynStokesApproximationEnum : return "PattynStokesApproximation"; + case StokesApproximationEnum : return "StokesApproximation"; + 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 QuadRiftFrontEnum : return "QuadRiftFront"; + case RiftfrontEnum : return "Riftfront"; + case SegmentRiftfrontEnum : return "SegmentRiftfront"; + case MacAyeal2dIceFrontEnum : return "MacAyeal2dIceFront"; + case MacAyeal3dIceFrontEnum : return "MacAyeal3dIceFront"; + case PattynIceFrontEnum : return "PattynIceFront"; + case StokesIceFrontEnum : return "StokesIceFront"; + 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 ControlInputEnum : return "ControlInput"; + 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 IntVecParamEnum : return "IntVecParam"; + 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 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 FreeEnum : return "Free"; + case OpenEnum : return "Open"; + case ClosedEnum : return "Closed"; + 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 BathymetryEnum : return "Bathymetry"; + case BedSlopeXEnum : return "BedSlopeX"; + case BedSlopeYEnum : return "BedSlopeY"; + case BoundaryEnum : return "Boundary"; + case CmResponseEnum : return "CmResponse"; + case CmResponsesEnum : return "CmResponses"; + case CmNoiseDmpEnum : return "CmNoiseDmp"; + case ConstantEnum : return "Constant"; + case NumControlsEnum : return "NumControls"; + 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 TimeAdaptEnum : return "TimeAdapt"; + case CflCoefficientEnum : return "CflCoefficient"; + 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 FractionIncrementEnum : return "FractionIncrement"; + case FrictionEnum : return "Friction"; + case GeothermalFluxEnum : return "GeothermalFlux"; + case HydrostaticAdjustmentEnum : return "HydrostaticAdjustment"; + case InternalEnum : return "Internal"; + case KflagEnum : return "Kflag"; + case IuToExtEnum : return "IuToExt"; + case ExtToIuEnum : return "ExtToIu"; + case MassFluxEnum : return "MassFlux"; + case ThicknessAbsMisfitEnum : return "ThicknessAbsMisfit"; + case SurfaceAbsVelMisfitEnum : return "SurfaceAbsVelMisfit"; + case SurfaceRelVelMisfitEnum : return "SurfaceRelVelMisfit"; + case SurfaceLogVelMisfitEnum : return "SurfaceLogVelMisfit"; + case SurfaceLogVxVyMisfitEnum : return "SurfaceLogVxVyMisfit"; + case SurfaceAverageVelMisfitEnum : return "SurfaceAverageVelMisfit"; + case MaxPenetrationEnum : return "MaxPenetration"; + case MeanVelEnum : return "MeanVel"; + case MeltingOffsetEnum : return "MeltingOffset"; + case GroundingLineMeltingRateEnum : return "GroundingLineMeltingRate"; + 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 PressurePicardEnum : return "PressurePicard"; + case VelocityEnum : return "Velocity"; + case QmuPressureEnum : return "QmuPressure"; + case ResetPenaltiesEnum : return "ResetPenalties"; + case RheologyBEnum : return "RheologyB"; + case RheologyBbarEnum : return "RheologyBbar"; + case RheologyNEnum : return "RheologyN"; + case SegmentOnIceShelfEnum : return "SegmentOnIceShelf"; + case ShelfDampeningEnum : return "ShelfDampening"; + 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 TemperaturePicardEnum : return "TemperaturePicard"; + case TemperatureOldEnum : return "TemperatureOld"; + case ThicknessEnum : return "Thickness"; + case ThicknessCoeffEnum : return "ThicknessCoeff"; + case ThicknessObsEnum : return "ThicknessObs"; + 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 VxPicardEnum : return "VxPicard"; + case QmuVxEnum : return "QmuVx"; + case VyAverageEnum : return "VyAverage"; + case VyEnum : return "Vy"; + case VyObsEnum : return "VyObs"; + case VyPicardEnum : return "VyPicard"; + case QmuVyEnum : return "QmuVy"; + case VzAverageEnum : return "VzAverage"; + case VzEnum : return "Vz"; + case VzObsEnum : return "VzObs"; + case VzPicardEnum : return "VzPicard"; + case VzMacAyealEnum : return "VzMacAyeal"; + case VzPattynEnum : return "VzPattyn"; + case VzStokesEnum : return "VzStokes"; + 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 BoolElementResultEnum : return "BoolElementResult"; + 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 OutputFrequencyEnum : return "OutputFrequency"; + case WaterColumnEnum : return "WaterColumn"; + case WaterColumnOldEnum : return "WaterColumnOld"; + case WaterColumnPicardEnum : return "WaterColumnPicard"; + case IoGatherEnum : return "IoGather"; + case MinVelEnum : return "MinVel"; + case MaxVelEnum : return "MaxVel"; + case MinVxEnum : return "MinVx"; + case MaxVxEnum : return "MaxVx"; + case MaxAbsVxEnum : return "MaxAbsVx"; + case MinVyEnum : return "MinVy"; + case MaxVyEnum : return "MaxVy"; + case MaxAbsVyEnum : return "MaxAbsVy"; + case MinVzEnum : return "MinVz"; + case MaxVzEnum : return "MaxVz"; + case MaxAbsVzEnum : return "MaxAbsVz"; + case RelativeEnum : return "Relative"; + case ResidualEnum : return "Residual"; + case AbsoluteEnum : return "Absolute"; + case IncrementalEnum : return "Incremental"; + case NoneEnum : return "None"; + case AgressiveMigrationEnum : return "AgressiveMigration"; + case SoftMigrationEnum : return "SoftMigration"; + case RhoIceEnum : return "RhoIce"; + case RhoWaterEnum : return "RhoWater"; + case GravityEnum : return "Gravity"; + case ThermalConductivityEnum : return "ThermalConductivity"; + case MeltingRateCorrectionEnum : return "MeltingRateCorrection"; + case MeltingRateCorrectionApplyEnum : return "MeltingRateCorrectionApply"; + case MixedLayerCapacityEnum : return "MixedLayerCapacity"; + case ThermalExchangeVelocityEnum : return "ThermalExchangeVelocity"; + case StokesSolverEnum : return "StokesSolver"; + 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 Gradient1Enum : return "Gradient1"; + case Gradient2Enum : return "Gradient2"; + case Gradient3Enum : return "Gradient3"; + case OldGradientEnum : return "OldGradient"; + case ConnectivityEnum : return "Connectivity"; + 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 KffEnum : return "Kff"; + 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 NumberOfElementsEnum : return "NumberOfElements"; + case NumberOfNodesEnum : return "NumberOfNodes"; + case NumberOfVerticesEnum : return "NumberOfVertices"; + case OptScalEnum : return "OptScal"; + case OutputFilePointerEnum : return "OutputFilePointer"; + case OutputFileNameEnum : return "OutputFileName"; + 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 QmuNumberOfResponsesEnum : return "QmuNumberOfResponses"; + case QmuSaveFemmodelEnum : return "QmuSaveFemmodel"; + case IndexedEnum : return "Indexed"; + case RegularEnum : return "Regular"; + case IndexEnum : return "Index"; + case ScaledEnum : return "Scaled"; + case NodalEnum : return "Nodal"; + case ResponseDescriptorsEnum : return "ResponseDescriptors"; + case PetscRcEnum : return "PetscRc"; + case SparsityEnum : return "Sparsity"; + case TolXEnum : return "TolX"; + case VariableDescriptorsEnum : return "VariableDescriptors"; + case VerboseEnum : return "Verbose"; + case WaitOnLockEnum : return "WaitOnLock"; + case PetscOptionsStringsEnum : return "PetscOptionsStrings"; + case PetscOptionsAnalysesEnum : return "PetscOptionsAnalyses"; + case GsetEnum : return "Gset"; + case FsetEnum : return "Fset"; + case SsetEnum : return "Sset"; + case GroundingLineMigrationEnum : return "GroundingLineMigration"; + case YtsEnum : return "Yts"; + case TriangleInterpEnum : return "TriangleInterp"; + case BilinearInterpEnum : return "BilinearInterp"; + case NearestInterpEnum : return "NearestInterp"; + case OptionEnum : return "Option"; + case OptionCellEnum : return "OptionCell"; + case OptionCharEnum : return "OptionChar"; + case OptionDoubleEnum : return "OptionDouble"; + case OptionLogicalEnum : return "OptionLogical"; + case OptionStructEnum : return "OptionStruct"; + case RheologyLawEnum : return "RheologyLaw"; + case PatersonEnum : return "Paterson"; + case ArrheniusEnum : return "Arrhenius"; + case VxMeshEnum : return "VxMesh"; + case VyMeshEnum : return "VyMesh"; + case VzMeshEnum : return "VzMesh"; + default : return "unknown"; + + } +} Index: /issm/trunk/src/c/modules/EnumToStringx/EnumToStringx.h =================================================================== --- /issm/trunk/src/c/modules/EnumToStringx/EnumToStringx.h (revision 8224) +++ /issm/trunk/src/c/modules/EnumToStringx/EnumToStringx.h (revision 8224) @@ -0,0 +1,10 @@ +/* + * \file EnumToStringx + * \brief: convert Enum To String + */ + +#ifndef _ENUM_TO_STRINGX_ + +char *EnumToStringx(int enum_in); + +#endif Index: /issm/trunk/src/c/modules/GetSolutionFromInputsx/GetSolutionFromInputsx.cpp =================================================================== --- /issm/trunk/src/c/modules/GetSolutionFromInputsx/GetSolutionFromInputsx.cpp (revision 8223) +++ /issm/trunk/src/c/modules/GetSolutionFromInputsx/GetSolutionFromInputsx.cpp (revision 8224) @@ -26,5 +26,5 @@ /*Get size of vector: */ gsize=nodes->NumberOfDofs(configuration_type,GsetEnum); - if (gsize==0) _error_("Allocating a Vec of size 0 as gsize=0 for configuration: %s",EnumToString(configuration_type)); + if (gsize==0) _error_("Allocating a Vec of size 0 as gsize=0 for configuration: %s",EnumToStringx(configuration_type)); /*Initialize solution: */ Index: /issm/trunk/src/c/modules/GetVectorFromInputsx/GetVectorFromInputsx.cpp =================================================================== --- /issm/trunk/src/c/modules/GetVectorFromInputsx/GetVectorFromInputsx.cpp (revision 8223) +++ /issm/trunk/src/c/modules/GetVectorFromInputsx/GetVectorFromInputsx.cpp (revision 8224) @@ -23,5 +23,5 @@ } } - else _error_("%s%s%s"," vector type: ",EnumToString(type)," not supported yet!"); + else _error_("%s%s%s"," vector type: ",EnumToStringx(type)," not supported yet!"); VecAssemblyBegin(vector); Index: /issm/trunk/src/c/modules/GroundingLineMigrationx/GroundingLineMigrationx.cpp =================================================================== --- /issm/trunk/src/c/modules/GroundingLineMigrationx/GroundingLineMigrationx.cpp (revision 8223) +++ /issm/trunk/src/c/modules/GroundingLineMigrationx/GroundingLineMigrationx.cpp (revision 8224) @@ -26,5 +26,5 @@ else if(migration_style==SoftMigrationEnum) SoftMigration(elements,nodes, vertices,loads,materials, parameters); else if(migration_style==NoneEnum) _printf_(true,"%s\n","NoneEnum supplied for migration style, doing nothing!"); - else _error_("%s not supported yet!",EnumToString(migration_style)); + else _error_("%s not supported yet!",EnumToStringx(migration_style)); } Index: /issm/trunk/src/c/modules/InputUpdateFromDakotax/InputUpdateFromDakotax.cpp =================================================================== --- /issm/trunk/src/c/modules/InputUpdateFromDakotax/InputUpdateFromDakotax.cpp (revision 8223) +++ /issm/trunk/src/c/modules/InputUpdateFromDakotax/InputUpdateFromDakotax.cpp (revision 8224) @@ -50,5 +50,5 @@ /*Now, pick up the parameter corresponding to root: */ - if(!parameters->FindParam(¶meter,NULL,StringToEnum(root))){ + if(!parameters->FindParam(¶meter,NULL,StringToEnumx(root))){ _error_("%s%s"," could not find Qmu parameter: ",root); } @@ -66,5 +66,5 @@ PetscSynchronizedFlush(MPI_COMM_WORLD); } - PetscSynchronizedPrintf(MPI_COMM_WORLD," descriptor: %s root %s enum: %i\n",descriptor,root,StringToEnum(root)); + PetscSynchronizedPrintf(MPI_COMM_WORLD," descriptor: %s root %s enum: %i\n",descriptor,root,StringToEnumx(root)); PetscSynchronizedFlush(MPI_COMM_WORLD); #endif @@ -72,5 +72,5 @@ /*Update inputs using the parameter vector: */ - InputUpdateFromVectorDakotax( elements,nodes, vertices,loads, materials, parameters, parameter, StringToEnum(root), VertexEnum); + InputUpdateFromVectorDakotax( elements,nodes, vertices,loads, materials, parameters, parameter, StringToEnumx(root), VertexEnum); /*increment i to skip the distributed values just collected: */ @@ -89,5 +89,5 @@ else{ /*Ok, standard variable, just update inputs using the variable: */ - InputUpdateFromConstantx( elements,nodes, vertices,loads, materials, parameters, variables[i],StringToEnum(descriptor)); + InputUpdateFromConstantx( elements,nodes, vertices,loads, materials, parameters, variables[i],StringToEnumx(descriptor)); } } Index: /issm/trunk/src/c/modules/InterpFromGridToMeshx/InterpFromGridToMeshx.cpp =================================================================== --- /issm/trunk/src/c/modules/InterpFromGridToMeshx/InterpFromGridToMeshx.cpp (revision 8223) +++ /issm/trunk/src/c/modules/InterpFromGridToMeshx/InterpFromGridToMeshx.cpp (revision 8224) @@ -170,5 +170,5 @@ break; default: - printf("Interpolation %s not supported yet\n",EnumToString(interpenum)); + printf("Interpolation %s not supported yet\n",EnumToStringx(interpenum)); return NULL; /*WARNING: no error because it would blow up the multithreading!*/ } Index: /issm/trunk/src/c/modules/ModelProcessorx/Control/UpdateElementsAndMaterialsControl.cpp =================================================================== --- /issm/trunk/src/c/modules/ModelProcessorx/Control/UpdateElementsAndMaterialsControl.cpp (revision 8223) +++ /issm/trunk/src/c/modules/ModelProcessorx/Control/UpdateElementsAndMaterialsControl.cpp (revision 8224) @@ -51,5 +51,5 @@ break; default: - _error_("Control %s not implemented yet",EnumToString((int)iomodel->control_type[i])); + _error_("Control %s not implemented yet",EnumToStringx((int)iomodel->control_type[i])); } } Index: /issm/trunk/src/c/modules/ModelProcessorx/CreateDataSets.cpp =================================================================== --- /issm/trunk/src/c/modules/ModelProcessorx/CreateDataSets.cpp (revision 8223) +++ /issm/trunk/src/c/modules/ModelProcessorx/CreateDataSets.cpp (revision 8224) @@ -108,5 +108,5 @@ break; default: - _error_("%s%s%s"," analysis_type: ",EnumToString(analysis_type)," not supported yet!"); + _error_("%s%s%s"," analysis_type: ",EnumToStringx(analysis_type)," not supported yet!"); } Index: /issm/trunk/src/c/modules/ModelProcessorx/DistributeNumDofs.cpp =================================================================== --- /issm/trunk/src/c/modules/ModelProcessorx/DistributeNumDofs.cpp (revision 8223) +++ /issm/trunk/src/c/modules/ModelProcessorx/DistributeNumDofs.cpp (revision 8224) @@ -61,5 +61,5 @@ doftype[5]=StokesApproximationEnum; } - else _error_("Approximationtype %i (%s) not implemented yet for DiagnosticHoriz",(int)*vertices_type,EnumToString((int)*vertices_type)); + else _error_("Approximationtype %i (%s) not implemented yet for DiagnosticHoriz",(int)*vertices_type,EnumToStringx((int)*vertices_type)); } else if (analysis_type==DiagnosticVertAnalysisEnum){ @@ -90,5 +90,5 @@ numdofs=1; } - else _error_("analysis type: %i (%s) not implemented yet",analysis_type,EnumToString(analysis_type)); + else _error_("analysis type: %i (%s) not implemented yet",analysis_type,EnumToStringx(analysis_type)); /*Now initialize the index*/ Index: /issm/trunk/src/c/modules/ModelProcessorx/ModelProcessorx.cpp =================================================================== --- /issm/trunk/src/c/modules/ModelProcessorx/ModelProcessorx.cpp (revision 8223) +++ /issm/trunk/src/c/modules/ModelProcessorx/ModelProcessorx.cpp (revision 8224) @@ -40,5 +40,5 @@ analysis_type=analysis_type_list[i]; - _printf_(VerboseMProcessor()," create datasets for analysis %s\n",EnumToString(analysis_type)); + _printf_(VerboseMProcessor()," create datasets for analysis %s\n",EnumToStringx(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 8223) +++ /issm/trunk/src/c/modules/ModelProcessorx/Qmu/CreateParametersQmu.cpp (revision 8224) @@ -74,5 +74,4 @@ parameters->AddObject(new StringParam(QmuErrNameEnum,qmuerrname)); /*}}}*/ - /*Deal with variable descriptors: {{{1*/ variabledescriptors=(char**)xmalloc(iomodel->numvariabledescriptors*sizeof(char*)); @@ -101,5 +100,4 @@ /*}}}*/ - /*Deal with response descriptors: {{{1*/ responsedescriptors=(char**)xmalloc(iomodel->numresponsedescriptors*sizeof(char*)); @@ -125,5 +123,4 @@ parameters->AddObject(new IntParam(QmuNumberOfResponsesEnum,iomodel->numberofresponses)); /*}}}*/ - /*Deal with partitioning: {{{1*/ /*partition vertices in iomodel->qmu_npart parts, unless a partition is already present: */ @@ -142,5 +139,4 @@ parameters->AddObject(new DoubleVecParam(QmuPartEnum,dpart,iomodel->numberofvertices)); /*}}}*/ - /*Deal with data needed because of qmu variables: {{{1*/ @@ -152,11 +148,11 @@ /*Recover data: */ - IoModelFetchData(&dakota_parameter,NULL,NULL,iomodel_handle,EnumToModelField(StringToEnum(tag))); + IoModelFetchData(&dakota_parameter,NULL,NULL,iomodel_handle,EnumToModelField(StringToEnumx(tag))); /*Convert units: */ - UnitConversion(dakota_parameter,iomodel->numberofvertices,ExtToIuEnum,StringToEnum(tag),parameters); + UnitConversion(dakota_parameter,iomodel->numberofvertices,ExtToIuEnum,StringToEnumx(tag),parameters); /*Add to parameters: */ - parameters->AddObject(new DoubleVecParam(StringToEnum(tag),dakota_parameter,iomodel->numberofvertices)); + parameters->AddObject(new DoubleVecParam(StringToEnumx(tag),dakota_parameter,iomodel->numberofvertices)); /*Free ressources:*/ @@ -165,5 +161,4 @@ } /*}}}*/ - /*Deal with data needed to compute qmu responses: {{{1*/ for(i=0;inumresponsedescriptors;i++){ Index: /issm/trunk/src/c/modules/OutputResultsx/OutputResultsx.cpp =================================================================== --- /issm/trunk/src/c/modules/OutputResultsx/OutputResultsx.cpp (revision 8223) +++ /issm/trunk/src/c/modules/OutputResultsx/OutputResultsx.cpp (revision 8224) @@ -45,5 +45,5 @@ if(my_rank==0){ parameters->FindParam(&solutiontype,SolutionTypeEnum); - results->AddObject(new StringExternalResult(results->Size()+1,SolutionTypeEnum,EnumToString(solutiontype),1,0)); + results->AddObject(new StringExternalResult(results->Size()+1,SolutionTypeEnum,EnumToStringx(solutiontype),1,0)); } Index: /issm/trunk/src/c/modules/Qmux/SpawnCoreParallel.cpp =================================================================== --- /issm/trunk/src/c/modules/Qmux/SpawnCoreParallel.cpp (revision 8223) +++ /issm/trunk/src/c/modules/Qmux/SpawnCoreParallel.cpp (revision 8224) @@ -66,5 +66,5 @@ /*Determine solution sequence: */ - _printf_(VerboseQmu(),"%s%s%s\n","Starting ",EnumToString(solution_type)," core:"); + _printf_(VerboseQmu(),"%s%s%s\n","Starting ",EnumToStringx(solution_type)," core:"); SolutionConfiguration(NULL,NULL,&solutioncore,solution_type); if(control_analysis)solutioncore=&control_core; Index: /issm/trunk/src/c/modules/Responsex/Responsex.cpp =================================================================== --- /issm/trunk/src/c/modules/Responsex/Responsex.cpp (revision 8223) +++ /issm/trunk/src/c/modules/Responsex/Responsex.cpp (revision 8224) @@ -18,5 +18,5 @@ void Responsex(double* responses,Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads,Materials* materials, Parameters* parameters,char* response_descriptor,bool process_units){ - switch (StringToEnum(response_descriptor)){ + switch (StringToEnumx(response_descriptor)){ case MinVelEnum: MinVelx( responses, elements,nodes, vertices, loads, materials, parameters,process_units); break; Index: /issm/trunk/src/c/modules/StringToEnumx/StringToEnumx.cpp =================================================================== --- /issm/trunk/src/c/modules/StringToEnumx/StringToEnumx.cpp (revision 8224) +++ /issm/trunk/src/c/modules/StringToEnumx/StringToEnumx.cpp (revision 8224) @@ -0,0 +1,389 @@ +/* +* \file StringToEnumx.cpp: +* \brief: output enum associated with string +* +* WARNING: DO NOT MODIFY THIS FILE +* this file has been automatically generated by Synchronize.sh +* Please read README for more information +*/ + +#include "../../shared/shared.h" +#include "../../include/include.h" +#include "./StringToEnumx.h" + +int StringToEnumx(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,"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,"AdjointSolution")==0) return AdjointSolutionEnum; + else if (strcmp(name,"AdjointHorizAnalysis")==0) return AdjointHorizAnalysisEnum; + else if (strcmp(name,"AdjointBalancedthicknessAnalysis")==0) return AdjointBalancedthicknessAnalysisEnum; + 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,"HydrologySolution")==0) return HydrologySolutionEnum; + else if (strcmp(name,"HydrologyAnalysis")==0) return HydrologyAnalysisEnum; + 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,"GroundingLineMigration2DSolution")==0) return GroundingLineMigration2DSolutionEnum; + 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,"FlaimSolution")==0) return FlaimSolutionEnum; + else if (strcmp(name,"FlaimAnalysis")==0) return FlaimAnalysisEnum; + else if (strcmp(name,"NoneAnalysis")==0) return NoneAnalysisEnum; + else if (strcmp(name,"Approximation")==0) return ApproximationEnum; + else if (strcmp(name,"HutterApproximation")==0) return HutterApproximationEnum; + else if (strcmp(name,"MacAyealApproximation")==0) return MacAyealApproximationEnum; + else if (strcmp(name,"MacAyealPattynApproximation")==0) return MacAyealPattynApproximationEnum; + else if (strcmp(name,"MacAyealStokesApproximation")==0) return MacAyealStokesApproximationEnum; + else if (strcmp(name,"NoneApproximation")==0) return NoneApproximationEnum; + else if (strcmp(name,"PattynApproximation")==0) return PattynApproximationEnum; + else if (strcmp(name,"PattynStokesApproximation")==0) return PattynStokesApproximationEnum; + else if (strcmp(name,"StokesApproximation")==0) return StokesApproximationEnum; + else if (strcmp(name,"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,"QuadRiftFront")==0) return QuadRiftFrontEnum; + else if (strcmp(name,"Riftfront")==0) return RiftfrontEnum; + else if (strcmp(name,"SegmentRiftfront")==0) return SegmentRiftfrontEnum; + else if (strcmp(name,"MacAyeal2dIceFront")==0) return MacAyeal2dIceFrontEnum; + else if (strcmp(name,"MacAyeal3dIceFront")==0) return MacAyeal3dIceFrontEnum; + else if (strcmp(name,"PattynIceFront")==0) return PattynIceFrontEnum; + else if (strcmp(name,"StokesIceFront")==0) return StokesIceFrontEnum; + 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,"ControlInput")==0) return ControlInputEnum; + 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,"IntVecParam")==0) return IntVecParamEnum; + 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,"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,"Free")==0) return FreeEnum; + else if (strcmp(name,"Open")==0) return OpenEnum; + else if (strcmp(name,"Closed")==0) return ClosedEnum; + 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,"Bathymetry")==0) return BathymetryEnum; + 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,"CmResponse")==0) return CmResponseEnum; + else if (strcmp(name,"CmResponses")==0) return CmResponsesEnum; + else if (strcmp(name,"CmNoiseDmp")==0) return CmNoiseDmpEnum; + else if (strcmp(name,"Constant")==0) return ConstantEnum; + else if (strcmp(name,"NumControls")==0) return NumControlsEnum; + 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,"TimeAdapt")==0) return TimeAdaptEnum; + else if (strcmp(name,"CflCoefficient")==0) return CflCoefficientEnum; + 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,"FractionIncrement")==0) return FractionIncrementEnum; + else if (strcmp(name,"Friction")==0) return FrictionEnum; + else if (strcmp(name,"GeothermalFlux")==0) return GeothermalFluxEnum; + else if (strcmp(name,"HydrostaticAdjustment")==0) return HydrostaticAdjustmentEnum; + else if (strcmp(name,"Internal")==0) return InternalEnum; + else if (strcmp(name,"Kflag")==0) return KflagEnum; + else if (strcmp(name,"IuToExt")==0) return IuToExtEnum; + else if (strcmp(name,"ExtToIu")==0) return ExtToIuEnum; + else if (strcmp(name,"MassFlux")==0) return MassFluxEnum; + else if (strcmp(name,"ThicknessAbsMisfit")==0) return ThicknessAbsMisfitEnum; + else if (strcmp(name,"SurfaceAbsVelMisfit")==0) return SurfaceAbsVelMisfitEnum; + else if (strcmp(name,"SurfaceRelVelMisfit")==0) return SurfaceRelVelMisfitEnum; + else if (strcmp(name,"SurfaceLogVelMisfit")==0) return SurfaceLogVelMisfitEnum; + else if (strcmp(name,"SurfaceLogVxVyMisfit")==0) return SurfaceLogVxVyMisfitEnum; + else if (strcmp(name,"SurfaceAverageVelMisfit")==0) return SurfaceAverageVelMisfitEnum; + 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,"GroundingLineMeltingRate")==0) return GroundingLineMeltingRateEnum; + 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,"PressurePicard")==0) return PressurePicardEnum; + else if (strcmp(name,"Velocity")==0) return VelocityEnum; + 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,"RheologyBbar")==0) return RheologyBbarEnum; + else if (strcmp(name,"RheologyN")==0) return RheologyNEnum; + else if (strcmp(name,"SegmentOnIceShelf")==0) return SegmentOnIceShelfEnum; + else if (strcmp(name,"ShelfDampening")==0) return ShelfDampeningEnum; + 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,"TemperaturePicard")==0) return TemperaturePicardEnum; + else if (strcmp(name,"TemperatureOld")==0) return TemperatureOldEnum; + else if (strcmp(name,"Thickness")==0) return ThicknessEnum; + else if (strcmp(name,"ThicknessCoeff")==0) return ThicknessCoeffEnum; + else if (strcmp(name,"ThicknessObs")==0) return ThicknessObsEnum; + 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,"VxPicard")==0) return VxPicardEnum; + 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,"VyPicard")==0) return VyPicardEnum; + 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,"VzPicard")==0) return VzPicardEnum; + else if (strcmp(name,"VzMacAyeal")==0) return VzMacAyealEnum; + else if (strcmp(name,"VzPattyn")==0) return VzPattynEnum; + else if (strcmp(name,"VzStokes")==0) return VzStokesEnum; + 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,"BoolElementResult")==0) return BoolElementResultEnum; + 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,"OutputFrequency")==0) return OutputFrequencyEnum; + else if (strcmp(name,"WaterColumn")==0) return WaterColumnEnum; + else if (strcmp(name,"WaterColumnOld")==0) return WaterColumnOldEnum; + else if (strcmp(name,"WaterColumnPicard")==0) return WaterColumnPicardEnum; + else if (strcmp(name,"IoGather")==0) return IoGatherEnum; + else if (strcmp(name,"MinVel")==0) return MinVelEnum; + else if (strcmp(name,"MaxVel")==0) return MaxVelEnum; + else if (strcmp(name,"MinVx")==0) return MinVxEnum; + else if (strcmp(name,"MaxVx")==0) return MaxVxEnum; + else if (strcmp(name,"MaxAbsVx")==0) return MaxAbsVxEnum; + else if (strcmp(name,"MinVy")==0) return MinVyEnum; + else if (strcmp(name,"MaxVy")==0) return MaxVyEnum; + else if (strcmp(name,"MaxAbsVy")==0) return MaxAbsVyEnum; + else if (strcmp(name,"MinVz")==0) return MinVzEnum; + else if (strcmp(name,"MaxVz")==0) return MaxVzEnum; + else if (strcmp(name,"MaxAbsVz")==0) return MaxAbsVzEnum; + else if (strcmp(name,"Relative")==0) return RelativeEnum; + else if (strcmp(name,"Residual")==0) return ResidualEnum; + else if (strcmp(name,"Absolute")==0) return AbsoluteEnum; + else if (strcmp(name,"Incremental")==0) return IncrementalEnum; + else if (strcmp(name,"None")==0) return NoneEnum; + else if (strcmp(name,"AgressiveMigration")==0) return AgressiveMigrationEnum; + else if (strcmp(name,"SoftMigration")==0) return SoftMigrationEnum; + 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,"MeltingRateCorrection")==0) return MeltingRateCorrectionEnum; + else if (strcmp(name,"MeltingRateCorrectionApply")==0) return MeltingRateCorrectionApplyEnum; + else if (strcmp(name,"MixedLayerCapacity")==0) return MixedLayerCapacityEnum; + else if (strcmp(name,"ThermalExchangeVelocity")==0) return ThermalExchangeVelocityEnum; + else if (strcmp(name,"StokesSolver")==0) return StokesSolverEnum; + 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,"Gradient1")==0) return Gradient1Enum; + else if (strcmp(name,"Gradient2")==0) return Gradient2Enum; + else if (strcmp(name,"Gradient3")==0) return Gradient3Enum; + else if (strcmp(name,"OldGradient")==0) return OldGradientEnum; + else if (strcmp(name,"Connectivity")==0) return ConnectivityEnum; + 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,"Kff")==0) return KffEnum; + 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,"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,"OutputFileName")==0) return OutputFileNameEnum; + 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,"QmuNumberOfResponses")==0) return QmuNumberOfResponsesEnum; + else if (strcmp(name,"QmuSaveFemmodel")==0) return QmuSaveFemmodelEnum; + else if (strcmp(name,"Indexed")==0) return IndexedEnum; + else if (strcmp(name,"Regular")==0) return RegularEnum; + else if (strcmp(name,"Index")==0) return IndexEnum; + else if (strcmp(name,"Scaled")==0) return ScaledEnum; + else if (strcmp(name,"Nodal")==0) return NodalEnum; + else if (strcmp(name,"ResponseDescriptors")==0) return ResponseDescriptorsEnum; + else if (strcmp(name,"PetscRc")==0) return PetscRcEnum; + 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,"PetscOptionsStrings")==0) return PetscOptionsStringsEnum; + else if (strcmp(name,"PetscOptionsAnalyses")==0) return PetscOptionsAnalysesEnum; + else if (strcmp(name,"Gset")==0) return GsetEnum; + else if (strcmp(name,"Fset")==0) return FsetEnum; + else if (strcmp(name,"Sset")==0) return SsetEnum; + else if (strcmp(name,"GroundingLineMigration")==0) return GroundingLineMigrationEnum; + else if (strcmp(name,"Yts")==0) return YtsEnum; + else if (strcmp(name,"TriangleInterp")==0) return TriangleInterpEnum; + else if (strcmp(name,"BilinearInterp")==0) return BilinearInterpEnum; + else if (strcmp(name,"NearestInterp")==0) return NearestInterpEnum; + else if (strcmp(name,"Option")==0) return OptionEnum; + else if (strcmp(name,"OptionCell")==0) return OptionCellEnum; + else if (strcmp(name,"OptionChar")==0) return OptionCharEnum; + else if (strcmp(name,"OptionDouble")==0) return OptionDoubleEnum; + else if (strcmp(name,"OptionLogical")==0) return OptionLogicalEnum; + else if (strcmp(name,"OptionStruct")==0) return OptionStructEnum; + else if (strcmp(name,"RheologyLaw")==0) return RheologyLawEnum; + else if (strcmp(name,"Paterson")==0) return PatersonEnum; + else if (strcmp(name,"Arrhenius")==0) return ArrheniusEnum; + else if (strcmp(name,"VxMesh")==0) return VxMeshEnum; + else if (strcmp(name,"VyMesh")==0) return VyMeshEnum; + else if (strcmp(name,"VzMesh")==0) return VzMeshEnum; + else _error_("Enum %s not found",name); + +} Index: /issm/trunk/src/c/modules/StringToEnumx/StringToEnumx.h =================================================================== --- /issm/trunk/src/c/modules/StringToEnumx/StringToEnumx.h (revision 8224) +++ /issm/trunk/src/c/modules/StringToEnumx/StringToEnumx.h (revision 8224) @@ -0,0 +1,10 @@ +/* + * \file StringToEnumx + * \brief: convert String to Enum + */ + +#ifndef _STRING_TO_ENUMX_ + +int StringToEnumx(char* string_in); + +#endif Index: /issm/trunk/src/c/modules/modules.h =================================================================== --- /issm/trunk/src/c/modules/modules.h (revision 8223) +++ /issm/trunk/src/c/modules/modules.h (revision 8224) @@ -26,4 +26,6 @@ #include "./DakotaResponsesx/DakotaResponsesx.h" #include "./ElementConnectivityx/ElementConnectivityx.h" +#include "./EnumToStringx/EnumToStringx.h" +#include "./StringToEnumx/StringToEnumx.h" #include "./GetSolutionFromInputsx/GetSolutionFromInputsx.h" #include "./GetVectorFromInputsx/GetVectorFromInputsx.h" Index: /issm/trunk/src/c/objects/Constraints/Spc.cpp =================================================================== --- /issm/trunk/src/c/objects/Constraints/Spc.cpp (revision 8223) +++ /issm/trunk/src/c/objects/Constraints/Spc.cpp (revision 8224) @@ -50,5 +50,5 @@ printf(" dof: %i\n",dof); printf(" value: %g\n",value); - printf(" analysis_type: %s\n",EnumToString(analysis_type)); + printf(" analysis_type: %s\n",EnumToStringx(analysis_type)); return; } @@ -62,5 +62,5 @@ printf(" dof: %i\n",dof); printf(" value: %g\n",value); - printf(" analysis_type: %s\n",EnumToString(analysis_type)); + printf(" analysis_type: %s\n",EnumToStringx(analysis_type)); return; } Index: /issm/trunk/src/c/objects/DofIndexing.cpp =================================================================== --- /issm/trunk/src/c/objects/DofIndexing.cpp (revision 8223) +++ /issm/trunk/src/c/objects/DofIndexing.cpp (revision 8224) @@ -141,5 +141,5 @@ else this->sdoflist=NULL; } - else _error_("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!"); + else _error_("%s%s%s"," set of enum type ",EnumToStringx(setenum)," not supported yet!"); Index: /issm/trunk/src/c/objects/ElementResults/BoolElementResult.cpp =================================================================== --- /issm/trunk/src/c/objects/ElementResults/BoolElementResult.cpp (revision 8223) +++ /issm/trunk/src/c/objects/ElementResults/BoolElementResult.cpp (revision 8224) @@ -49,5 +49,5 @@ printf("BoolElementResult:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type)); printf(" value: %s\n",this->value?"true":"false"); printf(" step: %i\n",this->step); Index: /issm/trunk/src/c/objects/ElementResults/DoubleElementResult.cpp =================================================================== --- /issm/trunk/src/c/objects/ElementResults/DoubleElementResult.cpp (revision 8223) +++ /issm/trunk/src/c/objects/ElementResults/DoubleElementResult.cpp (revision 8224) @@ -49,5 +49,5 @@ printf("DoubleElementResult:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(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 8223) +++ /issm/trunk/src/c/objects/ElementResults/PentaVertexElementResult.cpp (revision 8224) @@ -51,5 +51,5 @@ printf("PentaVertexElementResult:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(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 8223) +++ /issm/trunk/src/c/objects/ElementResults/TriaVertexElementResult.cpp (revision 8224) @@ -51,5 +51,5 @@ printf("TriaVertexElementResult:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(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 8223) +++ /issm/trunk/src/c/objects/Elements/Penta.cpp (revision 8224) @@ -482,6 +482,6 @@ input=inputs->GetInput(enum_type); } - if (!input) _error_("Input %s not found",EnumToString(enum_type)); - if (input->Enum()!=ControlInputEnum) _error_("Input %s is not a ControlInput",EnumToString(enum_type)); + if (!input) _error_("Input %s not found",EnumToStringx(enum_type)); + if (input->Enum()!=ControlInputEnum) _error_("Input %s is not a ControlInput",EnumToStringx(enum_type)); this->GetDofList1(&doflist1[0]); @@ -500,6 +500,6 @@ input=inputs->GetInput(enum_type); } - if (!input) _error_("Input %s not found",EnumToString(enum_type)); - if (input->Enum()!=ControlInputEnum) _error_("Input %s is not a ControlInput",EnumToString(enum_type)); + if (!input) _error_("Input %s not found",EnumToStringx(enum_type)); + if (input->Enum()!=ControlInputEnum) _error_("Input %s is not a ControlInput",EnumToStringx(enum_type)); ((ControlInput*)input)->ScaleGradient(scale); @@ -519,6 +519,6 @@ input=inputs->GetInput(enum_type); } - if (!input) _error_("Input %s not found",EnumToString(enum_type)); - if (input->Enum()!=ControlInputEnum) _error_("Input %s is not a ControlInput",EnumToString(enum_type)); + if (!input) _error_("Input %s not found",EnumToStringx(enum_type)); + if (input->Enum()!=ControlInputEnum) _error_("Input %s is not a ControlInput",EnumToStringx(enum_type)); this->GetDofList1(&doflist1[0]); @@ -574,5 +574,5 @@ break; default: - _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type)); + _error_("analysis %i (%s) not supported yet",analysis_type,EnumToStringx(analysis_type)); } @@ -1008,5 +1008,5 @@ return CreateKMatrixDiagnosticPattynStokes(); default: - _error_("Approximation %s not supported yet",EnumToString(approximation)); + _error_("Approximation %s not supported yet",EnumToStringx(approximation)); } } @@ -1190,5 +1190,5 @@ matice->GetViscosity3dStokes(&newviscosity,&epsilons[0]); } - else _error_("approximation %i (%s) not supported yet",approximation,EnumToString(approximation)); + else _error_("approximation %i (%s) not supported yet",approximation,EnumToStringx(approximation)); D_scalar=2*newviscosity*gauss->weight*Jdet; @@ -1921,5 +1921,5 @@ break; default: - _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type)); + _error_("analysis %i (%s) not supported yet",analysis_type,EnumToStringx(analysis_type)); } @@ -1947,5 +1947,5 @@ return CreatePVectorAdjointStokes(); default: - _error_("Approximation %s not supported yet",EnumToString(approximation)); + _error_("Approximation %s not supported yet",EnumToStringx(approximation)); } } @@ -2337,5 +2337,5 @@ return CreatePVectorDiagnosticPattynStokes(); default: - _error_("Approximation %s not supported yet",EnumToString(approximation)); + _error_("Approximation %s not supported yet",EnumToStringx(approximation)); } } @@ -3025,5 +3025,5 @@ GradjB(gradient); } - else _error_("control type %s not supported yet: ",EnumToString(control_type)); + else _error_("control type %s not supported yet: ",EnumToStringx(control_type)); } /*}}}*/ @@ -3103,5 +3103,5 @@ return; } - else _error_("approximation %s not supported yet",EnumToString(approximation)); + else _error_("approximation %s not supported yet",EnumToStringx(approximation)); } /*}}}*/ @@ -3205,5 +3205,5 @@ /*Recover input*/ Input* input=inputs->GetInput(enumtype); - if (!input) _error_("Input %s not found in element",EnumToString(enumtype)); + if (!input) _error_("Input %s not found in element",EnumToStringx(enumtype)); /*Checks in debugging mode*/ @@ -3254,5 +3254,5 @@ Input* input=inputs->GetInput(enumtype); - if(!input) _error_("No input of type %s found in tria",EnumToString(enumtype)); + if(!input) _error_("No input of type %s found in tria",EnumToStringx(enumtype)); GaussPenta* gauss=new GaussPenta(); @@ -3341,5 +3341,5 @@ } else{ - _error_("analysis: %i (%s) not supported yet",analysis_type,EnumToString(analysis_type)); + _error_("analysis: %i (%s) not supported yet",analysis_type,EnumToStringx(analysis_type)); } } @@ -3665,5 +3665,5 @@ /*Make a copy of the original input: */ input=(Input*)this->inputs->GetInput(enum_type); - if(!input)_error_(" could not find old input with enum: %s",EnumToString(enum_type)); + if(!input)_error_(" could not find old input with enum: %s",EnumToStringx(enum_type)); /*ArtificialNoise: */ @@ -3685,6 +3685,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])_error_("%s%s"," could not find input with enum ",EnumToString(enums[2*i+0])); - if(!old_inputs[i])_error_("%s%s"," could not find input with enum ",EnumToString(enums[2*i+0])); + if(!new_inputs[i])_error_("%s%s"," could not find input with enum ",EnumToStringx(enums[2*i+0])); + if(!old_inputs[i])_error_("%s%s"," could not find input with enum ",EnumToStringx(enums[2*i+0])); } @@ -3725,5 +3725,5 @@ } - if (input->Enum()!=ControlInputEnum) _error_("input %s is not a ControlInput",EnumToString(control_type[i])); + if (input->Enum()!=ControlInputEnum) _error_("input %s is not a ControlInput",EnumToStringx(control_type[i])); ((ControlInput*)input)->UpdateValue(scalar); @@ -3774,6 +3774,6 @@ original_input=(Input*)penta->matice->inputs->GetInput(enum_type); else - _error_("object %s not supported yet",EnumToString(object_enum)); - if(!original_input) _error_("could not find input with enum %s",EnumToString(enum_type)); + _error_("object %s not supported yet",EnumToStringx(object_enum)); + if(!original_input) _error_("could not find input with enum %s",EnumToStringx(enum_type)); /*If first time, initialize total_integrated_input*/ @@ -3786,5 +3786,5 @@ total_integrated_input=new DoubleInput(average_enum_type,0.0); else - _error_("object %s not supported yet",EnumToString(original_input->Enum())); + _error_("object %s not supported yet",EnumToStringx(original_input->Enum())); } @@ -3834,5 +3834,5 @@ this->matice->inputs->AddInput((Input*)depth_averaged_input); else - _error_("object %s not supported yet",EnumToString(object_enum)); + _error_("object %s not supported yet",EnumToStringx(object_enum)); } /*}}}*/ @@ -3864,6 +3864,6 @@ original_input=(Input*)matice->inputs->GetInput(enum_type); else - _error_("object of type %s not supported yet",EnumToString(object_type)); - if(!original_input) _error_("%s%s"," could not find input with enum:",EnumToString(enum_type)); + _error_("object of type %s not supported yet",EnumToStringx(object_type)); + if(!original_input) _error_("%s%s"," could not find input with enum:",EnumToStringx(enum_type)); original_input->Extrude(); @@ -3887,5 +3887,5 @@ penta->matice->inputs->AddInput((Input*)copy); else - _error_("object of type %s not supported yet",EnumToString(object_type)); + _error_("object of type %s not supported yet",EnumToStringx(object_type)); /*Stop if we have reached the surface*/ @@ -3904,5 +3904,5 @@ /*Make a copy of the original input: */ input=(Input*)this->inputs->GetInput(enum_type); - if(!input)_error_(" could not find old input with enum: %s",EnumToString(enum_type)); + if(!input)_error_(" could not find old input with enum: %s",EnumToStringx(enum_type)); /*Scale: */ @@ -3920,5 +3920,5 @@ if (enum_type==RheologyBbarEnum) input=this->matice->inputs->GetInput(RheologyBEnum); else input=this->inputs->GetInput(enum_type); - if (!input) _error_("Input %s not found in penta->inputs",EnumToString(enum_type)); + if (!input) _error_("Input %s not found in penta->inputs",EnumToStringx(enum_type)); /*If we don't find it, no big deal, just don't do the transfer. Otherwise, build a new Result @@ -4102,5 +4102,5 @@ /*Matice will take care of it*/ break; default: - _error_("Control %s not implemented yet",EnumToString((int)iomodel->control_type[i])); + _error_("Control %s not implemented yet",EnumToStringx((int)iomodel->control_type[i])); } } @@ -4134,5 +4134,5 @@ } else{ - _error_("Approximation type %s not supported yet",EnumToString((int)*(iomodel->elements_type+index))); + _error_("Approximation type %s not supported yet",EnumToStringx((int)*(iomodel->elements_type+index))); } } @@ -4196,5 +4196,5 @@ } else{ - _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type)); + _error_("analysis %i (%s) not supported yet",analysis_type,EnumToStringx(analysis_type)); } } @@ -4287,5 +4287,5 @@ Input* vz_input=inputs->GetInput(VzEnum); if (vz_input){ - if (vz_input->Enum()!=PentaVertexInputEnum) _error_("Cannot compute Vel as Vz is of type %s",EnumToString(vz_input->Enum())); + if (vz_input->Enum()!=PentaVertexInputEnum) _error_("Cannot compute Vel as Vz is of type %s",EnumToStringx(vz_input->Enum())); vz_input->GetValuesPtr(&vz_ptr,&dummy); for(i=0;iEnum()!=PentaVertexInputEnum){ - _error_("Cannot compute Vel as Vz is of type %s",EnumToString(vz_input->Enum())); + _error_("Cannot compute Vel as Vz is of type %s",EnumToStringx(vz_input->Enum())); } vz_input->GetValuesPtr(&vz_ptr,&dummy); @@ -4477,5 +4477,5 @@ if (vzmacayeal_input){ if (vzmacayeal_input->Enum()!=PentaVertexInputEnum){ - _error_("Cannot compute Vel as VzMacAyeal is of type %s",EnumToString(vzmacayeal_input->Enum())); + _error_("Cannot compute Vel as VzMacAyeal is of type %s",EnumToStringx(vzmacayeal_input->Enum())); } vzmacayeal_input->GetValuesPtr(&vzmacayeal_ptr,&dummy); @@ -4553,5 +4553,5 @@ if (vz_input){ if (vz_input->Enum()!=PentaVertexInputEnum){ - _error_("Cannot compute Vel as Vz is of type %s",EnumToString(vz_input->Enum())); + _error_("Cannot compute Vel as Vz is of type %s",EnumToStringx(vz_input->Enum())); } vz_input->GetValuesPtr(&vz_ptr,&dummy); @@ -4645,5 +4645,5 @@ if (vzpattyn_input){ if (vzpattyn_input->Enum()!=PentaVertexInputEnum){ - _error_("Cannot compute Vel as VzPattyn is of type %s",EnumToString(vzpattyn_input->Enum())); + _error_("Cannot compute Vel as VzPattyn is of type %s",EnumToStringx(vzpattyn_input->Enum())); } vzpattyn_input->GetValuesPtr(&vzpattyn_ptr,&dummy); @@ -4721,5 +4721,5 @@ if (vz_input){ if (vz_input->Enum()!=PentaVertexInputEnum){ - _error_("Cannot compute Vel as Vz is of type %s",EnumToString(vz_input->Enum())); + _error_("Cannot compute Vel as Vz is of type %s",EnumToStringx(vz_input->Enum())); } vz_input->GetValuesPtr(&vz_ptr,&dummy); @@ -4803,5 +4803,5 @@ Input* vx_input=inputs->GetInput(VxEnum); if (vx_input){ - if (vx_input->Enum()!=PentaVertexInputEnum) _error_("Cannot compute Vel as Vx is of type %s",EnumToString(vx_input->Enum())); + if (vx_input->Enum()!=PentaVertexInputEnum) _error_("Cannot compute Vel as Vx is of type %s",EnumToStringx(vx_input->Enum())); vx_input->GetValuesPtr(&vx_ptr,&dummy); for(i=0;iGetInput(VyEnum); if (vy_input){ - if (vy_input->Enum()!=PentaVertexInputEnum) _error_("Cannot compute Vel as Vy is of type %s",EnumToString(vy_input->Enum())); + if (vy_input->Enum()!=PentaVertexInputEnum) _error_("Cannot compute Vel as Vy is of type %s",EnumToStringx(vy_input->Enum())); vy_input->GetValuesPtr(&vy_ptr,&dummy); for(i=0;iGetInput(VzStokesEnum); if (vzstokes_input){ - if (vzstokes_input->Enum()!=PentaVertexInputEnum) _error_("Cannot compute Vel as VzStokes is of type %s",EnumToString(vy_input->Enum())); + if (vzstokes_input->Enum()!=PentaVertexInputEnum) _error_("Cannot compute Vel as VzStokes is of type %s",EnumToStringx(vy_input->Enum())); vzstokes_input->GetValuesPtr(&vzstokes_ptr,&dummy); for(i=0;iGetInput(VzStokesEnum); if (vzstokes_input){ - if (vzstokes_input->Enum()!=PentaVertexInputEnum) _error_("Cannot compute Vel as VzStokes is of type %s",EnumToString(vy_input->Enum())); + if (vzstokes_input->Enum()!=PentaVertexInputEnum) _error_("Cannot compute Vel as VzStokes is of type %s",EnumToStringx(vy_input->Enum())); vzstokes_input->GetValuesPtr(&vzstokes_ptr,&dummy); for(i=0;iGetInput(enum_type); } - if (!input) _error_("Input %s not found",EnumToString(enum_type)); - if (input->Enum()!=ControlInputEnum) _error_("Input %s is not a ControlInput",EnumToString(enum_type)); + if (!input) _error_("Input %s not found",EnumToStringx(enum_type)); + if (input->Enum()!=ControlInputEnum) _error_("Input %s is not a ControlInput",EnumToStringx(enum_type)); this->GetDofList1(&doflist1[0]); @@ -2758,6 +2758,6 @@ input=inputs->GetInput(enum_type); } - if (!input) _error_("Input %s not found",EnumToString(enum_type)); - if (input->Enum()!=ControlInputEnum) _error_("Input %s is not a ControlInput",EnumToString(enum_type)); + if (!input) _error_("Input %s not found",EnumToStringx(enum_type)); + if (input->Enum()!=ControlInputEnum) _error_("Input %s is not a ControlInput",EnumToStringx(enum_type)); ((ControlInput*)input)->ScaleGradient(scale); @@ -2777,6 +2777,6 @@ input=inputs->GetInput(enum_type); } - if (!input) _error_("Input %s not found",EnumToString(enum_type)); - if (input->Enum()!=ControlInputEnum) _error_("Input %s is not a ControlInput",EnumToString(enum_type)); + if (!input) _error_("Input %s not found",EnumToStringx(enum_type)); + if (input->Enum()!=ControlInputEnum) _error_("Input %s is not a ControlInput",EnumToStringx(enum_type)); this->GetDofList1(&doflist1[0]); @@ -2953,5 +2953,5 @@ /*Recover input*/ Input* input=inputs->GetInput(enumtype); - if (!input) _error_("Input %s not found in element",EnumToString(enumtype)); + if (!input) _error_("Input %s not found in element",EnumToStringx(enumtype)); /*Checks in debugging mode*/ @@ -2999,5 +2999,5 @@ Input* input=inputs->GetInput(enumtype); - if(!input) _error_("No input of type %s found in tria",EnumToString(enumtype)); + if(!input) _error_("No input of type %s found in tria",EnumToStringx(enumtype)); GaussTria* gauss=new GaussTria(); @@ -3031,5 +3031,5 @@ GetSolutionFromInputsHydrology(solution); else - _error_("analysis: %s not supported yet",EnumToString(analysis_type)); + _error_("analysis: %s not supported yet",EnumToStringx(analysis_type)); } @@ -3649,5 +3649,5 @@ /*Make a copy of the original input: */ input=(Input*)this->inputs->GetInput(enum_type); - if(!input)_error_(" could not find old input with enum: %s",EnumToString(enum_type)); + if(!input)_error_(" could not find old input with enum: %s",EnumToStringx(enum_type)); /*ArtificialNoise: */ @@ -3677,5 +3677,5 @@ if (input->Enum()!=ControlInputEnum){ - _error_("input %s is not a ControlInput",EnumToString(control_type[i])); + _error_("input %s is not a ControlInput",EnumToStringx(control_type[i])); } @@ -3704,6 +3704,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])_error_("%s%s"," could not find input with enum ",EnumToString(enums[2*i+0])); - if(!old_inputs[i])_error_("%s%s"," could not find input with enum ",EnumToString(enums[2*i+0])); + if(!new_inputs[i])_error_("%s%s"," could not find input with enum ",EnumToStringx(enums[2*i+0])); + if(!old_inputs[i])_error_("%s%s"," could not find input with enum ",EnumToStringx(enums[2*i+0])); } @@ -3733,6 +3733,6 @@ oldinput=(Input*)this->matice->inputs->GetInput(enum_type); else - _error_("object %s not supported yet",EnumToString(object_enum)); - if(!oldinput)_error_("%s%s"," could not find old input with enum: ",EnumToString(enum_type)); + _error_("object %s not supported yet",EnumToStringx(object_enum)); + if(!oldinput)_error_("%s%s"," could not find old input with enum: ",EnumToStringx(enum_type)); newinput=(Input*)oldinput->copy(); @@ -3746,5 +3746,5 @@ this->matice->inputs->AddInput((Input*)newinput); else - _error_("object %s not supported yet",EnumToString(object_enum)); + _error_("object %s not supported yet",EnumToStringx(object_enum)); } /*}}}*/ @@ -3764,5 +3764,5 @@ /*Make a copy of the original input: */ input=(Input*)this->inputs->GetInput(enum_type); - if(!input)_error_(" could not find old input with enum: %s",EnumToString(enum_type)); + if(!input)_error_(" could not find old input with enum: %s",EnumToStringx(enum_type)); /*Scale: */ @@ -3779,5 +3779,5 @@ if (enum_type==RheologyBbarEnum) input=this->matice->inputs->GetInput(enum_type); else input=this->inputs->GetInput(enum_type); - if (!input) _error_("Input %s not found in tria->inputs",EnumToString(enum_type)); + if (!input) _error_("Input %s not found in tria->inputs",EnumToStringx(enum_type)); /*If we don't find it, no big deal, just don't do the transfer. Otherwise, build a new Result @@ -3980,5 +3980,5 @@ /*Matice will take care of it*/ break; default: - _error_("Control %s not implemented yet",EnumToString((int)iomodel->control_type[i])); + _error_("Control %s not implemented yet",EnumToStringx((int)iomodel->control_type[i])); } } @@ -4032,5 +4032,5 @@ break; default: - _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type)); + _error_("analysis %i (%s) not supported yet",analysis_type,EnumToStringx(analysis_type)); } } @@ -4200,5 +4200,5 @@ if (vz_input){ if (vz_input->Enum()!=TriaVertexInputEnum){ - _error_("Cannot compute Vel as Vz is of type %s",EnumToString(vz_input->Enum())); + _error_("Cannot compute Vel as Vz is of type %s",EnumToStringx(vz_input->Enum())); } vz_input->GetValuesPtr(&vz_ptr,&dummy); @@ -4317,5 +4317,5 @@ bed[i]=bed_ptr[i]-rho_ice/rho_water*(values[i]-thickness_ptr[i]); //bed = oldbed + di * dH } - else _error_("Hydrostatic adjustment %i (%s) not supported yet",hydroadjustment,EnumToString(hydroadjustment)); + else _error_("Hydrostatic adjustment %i (%s) not supported yet",hydroadjustment,EnumToStringx(hydroadjustment)); } } @@ -4389,5 +4389,5 @@ default: - _error_("type %i (%s) not implemented yet",type,EnumToString(type)); + _error_("type %i (%s) not implemented yet",type,EnumToStringx(type)); } } @@ -4500,5 +4500,5 @@ default: - _error_("type %i (%s) not implemented yet",type,EnumToString(type)); + _error_("type %i (%s) not implemented yet",type,EnumToStringx(type)); } @@ -5046,5 +5046,5 @@ } else{ - _error_("unsupported control type: %s",EnumToString(control_type[i])); + _error_("unsupported control type: %s",EnumToStringx(control_type[i])); } } Index: /issm/trunk/src/c/objects/ExternalResults/BoolExternalResult.cpp =================================================================== --- /issm/trunk/src/c/objects/ExternalResults/BoolExternalResult.cpp (revision 8223) +++ /issm/trunk/src/c/objects/ExternalResults/BoolExternalResult.cpp (revision 8224) @@ -53,5 +53,5 @@ printf("BoolExternalResult:\n"); printf(" id: %i\n",this->id); - printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(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=EnumToString(this->enum_type); + name=EnumToStringx(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 EnumToString(this->enum_type); + return EnumToStringx(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/ExternalResults/DoubleExternalResult.cpp =================================================================== --- /issm/trunk/src/c/objects/ExternalResults/DoubleExternalResult.cpp (revision 8223) +++ /issm/trunk/src/c/objects/ExternalResults/DoubleExternalResult.cpp (revision 8224) @@ -53,5 +53,5 @@ printf("DoubleExternalResult:\n"); printf(" id: %i\n",this->id); - printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type)); printf(" value: %g\n",this->value); printf(" step: %i\n",this->step); @@ -155,5 +155,5 @@ /*First write enum: */ - name=EnumToString(this->enum_type); + name=EnumToStringx(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 EnumToString(this->enum_type); + return EnumToStringx(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/ExternalResults/DoubleMatExternalResult.cpp =================================================================== --- /issm/trunk/src/c/objects/ExternalResults/DoubleMatExternalResult.cpp (revision 8223) +++ /issm/trunk/src/c/objects/ExternalResults/DoubleMatExternalResult.cpp (revision 8224) @@ -58,5 +58,5 @@ printf("DoubleMatExternalResult:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(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,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type)); printf(" step: %i\n",this->step); printf(" time: %g\n",this->time); @@ -194,5 +194,5 @@ /*First write enum: */ - name=EnumToString(this->enum_type); + name=EnumToStringx(this->enum_type); length=(strlen(name)+1)*sizeof(char); fwrite(&length,sizeof(int),1,fid); @@ -216,5 +216,5 @@ /*FUNCTION DoubleMatExternalResult::GetResultName{{{1*/ char* DoubleMatExternalResult::GetResultName(void){ - return EnumToString(this->enum_type); + return EnumToStringx(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/ExternalResults/DoubleVecExternalResult.cpp =================================================================== --- /issm/trunk/src/c/objects/ExternalResults/DoubleVecExternalResult.cpp (revision 8223) +++ /issm/trunk/src/c/objects/ExternalResults/DoubleVecExternalResult.cpp (revision 8224) @@ -55,5 +55,5 @@ printf("DoubleVecExternalResult:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(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,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type)); printf(" vector size: %i\n",this->M); for(i=0;iM;i++){ @@ -180,5 +180,5 @@ /*First write enum: */ - name=EnumToString(this->enum_type); + name=EnumToStringx(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 EnumToString(this->enum_type); + return EnumToStringx(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/ExternalResults/IntExternalResult.cpp =================================================================== --- /issm/trunk/src/c/objects/ExternalResults/IntExternalResult.cpp (revision 8223) +++ /issm/trunk/src/c/objects/ExternalResults/IntExternalResult.cpp (revision 8224) @@ -53,5 +53,5 @@ printf("IntExternalResult:\n"); printf(" id: %i\n",this->id); - printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type)); printf(" value: %i\n",this->value); printf(" step: %i\n",this->step); @@ -156,5 +156,5 @@ /*First write enum: */ - name=EnumToString(this->enum_type); + name=EnumToStringx(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 EnumToString(this->enum_type); + return EnumToStringx(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/ExternalResults/PetscVecExternalResult.cpp =================================================================== --- /issm/trunk/src/c/objects/ExternalResults/PetscVecExternalResult.cpp (revision 8223) +++ /issm/trunk/src/c/objects/ExternalResults/PetscVecExternalResult.cpp (revision 8224) @@ -55,5 +55,5 @@ printf("PetscVecExternalResult:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type)); } @@ -65,5 +65,5 @@ printf("PetscVecExternalResult:\n"); printf(" id: %i\n",this->id); - printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type)); printf(" step: %i\n",this->step); printf(" time: %g\n",this->time); @@ -215,5 +215,5 @@ /*First write enum: */ - name=EnumToString(this->enum_type); + name=EnumToStringx(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 EnumToString(this->enum_type); + return EnumToStringx(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/ExternalResults/StringExternalResult.cpp =================================================================== --- /issm/trunk/src/c/objects/ExternalResults/StringExternalResult.cpp (revision 8223) +++ /issm/trunk/src/c/objects/ExternalResults/StringExternalResult.cpp (revision 8224) @@ -55,5 +55,5 @@ printf("StringExternalResult:\n"); printf(" id: %i\n",this->id); - printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type)); printf(" value: %s\n",this->value); printf(" step: %i\n",this->step); @@ -169,5 +169,5 @@ /*First write enum: */ - name=EnumToString(this->enum_type); + name=EnumToStringx(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 EnumToString(this->enum_type); + return EnumToStringx(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/FemModel.cpp =================================================================== --- /issm/trunk/src/c/objects/FemModel.cpp (revision 8223) +++ /issm/trunk/src/c/objects/FemModel.cpp (revision 8224) @@ -53,5 +53,5 @@ for(i=0;iSetCurrentConfiguration(analysis_type); @@ -127,7 +127,7 @@ printf(" number of fem models: %i\n",nummodels); printf(" analysis_type_list: \n"); - for(int i=0;iparameters,analysis_type); - _printf_(VerboseSolver()," petsc Options set for analysis type: %s\n",EnumToString(analysis_type)); + _printf_(VerboseSolver()," petsc Options set for analysis type: %s\n",EnumToStringx(analysis_type)); } Index: /issm/trunk/src/c/objects/Inputs/BoolInput.cpp =================================================================== --- /issm/trunk/src/c/objects/Inputs/BoolInput.cpp (revision 8223) +++ /issm/trunk/src/c/objects/Inputs/BoolInput.cpp (revision 8224) @@ -46,5 +46,5 @@ printf("BoolInput:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type)); printf(" value: %s\n",value?"true":"false"); } Index: /issm/trunk/src/c/objects/Inputs/ControlInput.cpp =================================================================== --- /issm/trunk/src/c/objects/Inputs/ControlInput.cpp (revision 8223) +++ /issm/trunk/src/c/objects/Inputs/ControlInput.cpp (revision 8224) @@ -48,5 +48,5 @@ break; default: - _error_("Input of Enum %s not supported yet by ControlInput",EnumToString(enum_input)); + _error_("Input of Enum %s not supported yet by ControlInput",EnumToStringx(enum_input)); } gradient =NULL; @@ -73,5 +73,5 @@ printf("ControlInput:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type)); printf("---values: \n"); if (values) values->Echo(); printf("---savedvalues: \n");if (savedvalues) savedvalues->Echo(); @@ -358,5 +358,5 @@ /*FUNCTION ControlInput::ScaleGradient{{{1*/ void ControlInput::ScaleGradient(double scaling_factor){ - if(!gradient) _error_("Gradient of ControlInput %s not found",EnumToString(enum_type)); + if(!gradient) _error_("Gradient of ControlInput %s not found",EnumToStringx(enum_type)); gradient->Scale(scaling_factor); }/*}}}*/ @@ -430,5 +430,5 @@ /*FUNCTION ControlInput::SaveValue{{{1*/ void ControlInput::SaveValue(void){ - if(!values) _error_("Values of %s not found",EnumToString(this->enum_type)); + if(!values) _error_("Values of %s not found",EnumToStringx(this->enum_type)); if(savedvalues) delete this->savedvalues; @@ -437,6 +437,6 @@ /*FUNCTION ControlInput::UpdateValue{{{1*/ void ControlInput::UpdateValue(double scalar){ - if(!gradient) _error_("Gradient of %s not found",EnumToString(this->enum_type)); - if(!savedvalues) _error_("Values of %s not found",EnumToString(this->enum_type)); + if(!gradient) _error_("Gradient of %s not found",EnumToStringx(this->enum_type)); + if(!savedvalues) _error_("Values of %s not found",EnumToStringx(this->enum_type)); if(values) delete this->values; Index: /issm/trunk/src/c/objects/Inputs/DoubleInput.cpp =================================================================== --- /issm/trunk/src/c/objects/Inputs/DoubleInput.cpp (revision 8223) +++ /issm/trunk/src/c/objects/Inputs/DoubleInput.cpp (revision 8224) @@ -46,5 +46,5 @@ printf("DoubleInput:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type)); printf(" value: %g\n",this->value); } @@ -160,5 +160,5 @@ *pvalue=(bool)value; #else - _error_("Double input of enum %s cannot return a boolean",EnumToString(enum_type)); + _error_("Double input of enum %s cannot return a boolean",EnumToStringx(enum_type)); #endif @@ -170,5 +170,5 @@ *pvalue=(int)value; #else - _error_("Double input of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type)); + _error_("Double input of enum %i (%s) cannot return an integer",enum_type,EnumToStringx(enum_type)); #endif @@ -291,5 +291,5 @@ /*Check that input provided is a thickness*/ - if (thickness_input->EnumType()!=ThicknessEnum) _error_("Input provided is not a Thickness (enum_type is %s)",EnumToString(thickness_input->EnumType())); + if (thickness_input->EnumType()!=ThicknessEnum) _error_("Input provided is not a Thickness (enum_type is %s)",EnumToStringx(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 8223) +++ /issm/trunk/src/c/objects/Inputs/IntInput.cpp (revision 8224) @@ -41,5 +41,5 @@ printf("IntInput:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(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 8223) +++ /issm/trunk/src/c/objects/Inputs/PentaVertexInput.cpp (revision 8224) @@ -57,5 +57,5 @@ printf("PentaVertexInput:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(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]); } @@ -545,5 +545,5 @@ /*Check that input provided is a thickness*/ - if (thickness_input->EnumType()!=ThicknessEnum) _error_("Input provided is not a Thickness (enum_type is %s)",EnumToString(thickness_input->EnumType())); + if (thickness_input->EnumType()!=ThicknessEnum) _error_("Input provided is not a Thickness (enum_type is %s)",EnumToStringx(thickness_input->EnumType())); /*Get Thickness value pointer*/ @@ -579,5 +579,5 @@ /*Check that inputB is of the same type*/ - if (inputB->Enum()!=PentaVertexInputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToString(inputB->Enum())); + if (inputB->Enum()!=PentaVertexInputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->Enum())); xinputB=(PentaVertexInput*)inputB; @@ -610,5 +610,5 @@ /*Check that inputB is of the same type*/ - if (inputB->Enum()!=PentaVertexInputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToString(inputB->Enum())); + if (inputB->Enum()!=PentaVertexInputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->Enum())); xinputB=(PentaVertexInput*)inputB; @@ -641,5 +641,5 @@ /*Check that inputB is of the same type*/ - if (inputB->Enum()!=PentaVertexInputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToString(inputB->Enum())); + if (inputB->Enum()!=PentaVertexInputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->Enum())); xinputB=(PentaVertexInput*)inputB; Index: /issm/trunk/src/c/objects/Inputs/TriaVertexInput.cpp =================================================================== --- /issm/trunk/src/c/objects/Inputs/TriaVertexInput.cpp (revision 8223) +++ /issm/trunk/src/c/objects/Inputs/TriaVertexInput.cpp (revision 8224) @@ -57,5 +57,5 @@ printf("TriaVertexInput:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type)); printf(" values: [%g %g %g]\n",this->values[0],this->values[1],this->values[2]); } @@ -417,5 +417,5 @@ /*Check that inputB is of the same type*/ - if (inputB->Enum()!=TriaVertexInputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToString(inputB->Enum())); + if (inputB->Enum()!=TriaVertexInputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->Enum())); xinputB=(TriaVertexInput*)inputB; @@ -448,5 +448,5 @@ /*Check that inputB is of the same type*/ - if (inputB->Enum()!=TriaVertexInputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToString(inputB->Enum())); + if (inputB->Enum()!=TriaVertexInputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->Enum())); xinputB=(TriaVertexInput*)inputB; Index: /issm/trunk/src/c/objects/Loads/Friction.cpp =================================================================== --- /issm/trunk/src/c/objects/Loads/Friction.cpp (revision 8223) +++ /issm/trunk/src/c/objects/Loads/Friction.cpp (revision 8224) @@ -49,5 +49,5 @@ void Friction::Echo(void){ printf("Friction:\n"); - printf(" analysis_type: %s\n",EnumToString(analysis_type)); + printf(" analysis_type: %s\n",EnumToStringx(analysis_type)); printf(" element_type: %s\n",this->element_type); inputs->Echo(); @@ -251,5 +251,5 @@ Input* input=inputs->GetInput(enum_type); - if(!input) _error_("input %s not found",EnumToString(enum_type)); + if(!input) _error_("input %s not found",EnumToStringx(enum_type)); input->GetParameterValue(pvalue,gauss); @@ -260,5 +260,5 @@ Input* input=inputs->GetInput(enum_type); - if(!input) _error_("input %s not found",EnumToString(enum_type)); + if(!input) _error_("input %s not found",EnumToStringx(enum_type)); input->GetParameterValue(pvalue,gauss); Index: /issm/trunk/src/c/objects/Loads/Icefront.cpp =================================================================== --- /issm/trunk/src/c/objects/Loads/Icefront.cpp (revision 8223) +++ /issm/trunk/src/c/objects/Loads/Icefront.cpp (revision 8224) @@ -74,5 +74,5 @@ icefront_node_ids[3]=iomodel->nodecounter+(int)*(iomodel->pressureload+segment_width*i+3); } - else _error_("in_icefront_type %s not supported yet!",EnumToString(in_icefront_type)); + else _error_("in_icefront_type %s not supported yet!",EnumToStringx(in_icefront_type)); if (in_icefront_type==PattynIceFrontEnum || in_icefront_type==StokesIceFrontEnum) num_nodes=4; @@ -118,5 +118,5 @@ printf("Icefront:\n"); printf(" id: %i\n",id); - printf(" analysis_type: %s\n",EnumToString(analysis_type)); + printf(" analysis_type: %s\n",EnumToStringx(analysis_type)); hnodes->Echo(); helement->Echo(); @@ -133,5 +133,5 @@ printf("Icefront:\n"); printf(" id: %i\n",id); - printf(" analysis_type: %s\n",EnumToString(analysis_type)); + printf(" analysis_type: %s\n",EnumToStringx(analysis_type)); hnodes->DeepEcho(); helement->DeepEcho(); @@ -334,5 +334,5 @@ break; default: - _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type)); + _error_("analysis %i (%s) not supported yet",analysis_type,EnumToStringx(analysis_type)); } @@ -432,5 +432,5 @@ return CreatePVectorDiagnosticStokes(); default: - _error_("Icefront type %s not supported yet",EnumToString(type)); + _error_("Icefront type %s not supported yet",EnumToStringx(type)); } } @@ -490,6 +490,6 @@ switch(fill){ case WaterEnum: - surface_under_water=min(0,thickness+bed); // 0 if the top of the glacier is above water level - base_under_water=min(0,bed); // 0 if the bottom of the glacier is above water level + surface_under_water=min(0.,thickness+bed); // 0 if the top of the glacier is above water level + base_under_water=min(0.,bed); // 0 if the bottom of the glacier is above water level water_pressure=1.0/2.0*gravity*rho_water*(pow(surface_under_water,2) - pow(base_under_water,2)); break; @@ -501,5 +501,5 @@ break; default: - _error_("fill type %s not supported yet",EnumToString(fill)); + _error_("fill type %s not supported yet",EnumToStringx(fill)); } ice_pressure=1.0/2.0*gravity*rho_ice*pow(thickness,2); @@ -603,5 +603,5 @@ switch(fill){ case WaterEnum: - water_pressure=rho_water*gravity*min(0,z_g);//0 if the gaussian point is above water level + water_pressure=rho_water*gravity*min(0.,z_g);//0 if the gaussian point is above water level break; case AirEnum: @@ -609,5 +609,5 @@ break; default: - _error_("fill type %s not supported yet",EnumToString(fill)); + _error_("fill type %s not supported yet",EnumToStringx(fill)); } ice_pressure=rho_ice*gravity*(surface-z_g); @@ -674,5 +674,5 @@ switch(fill){ case WaterEnum: - water_pressure=rho_water*gravity*min(0,z_g);//0 if the gaussian point is above water level + water_pressure=rho_water*gravity*min(0.,z_g);//0 if the gaussian point is above water level break; case AirEnum: @@ -680,5 +680,5 @@ break; default: - _error_("fill type %s not supported yet",EnumToString(fill)); + _error_("fill type %s not supported yet",EnumToStringx(fill)); } air_pressure=0; Index: /issm/trunk/src/c/objects/Loads/Numericalflux.cpp =================================================================== --- /issm/trunk/src/c/objects/Loads/Numericalflux.cpp (revision 8223) +++ /issm/trunk/src/c/objects/Loads/Numericalflux.cpp (revision 8224) @@ -148,5 +148,5 @@ printf("Numericalflux:\n"); printf(" id: %i\n",id); - printf(" analysis_type: %s\n",EnumToString(analysis_type)); + printf(" analysis_type: %s\n",EnumToStringx(analysis_type)); hnodes->Echo(); helement->Echo(); @@ -160,5 +160,5 @@ printf("Numericalflux:\n"); printf(" id: %i\n",id); - printf(" analysis_type: %s\n",EnumToString(analysis_type)); + printf(" analysis_type: %s\n",EnumToStringx(analysis_type)); hnodes->DeepEcho(); helement->DeepEcho(); @@ -346,5 +346,5 @@ break; default: - _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type)); + _error_("analysis %i (%s) not supported yet",analysis_type,EnumToStringx(analysis_type)); } @@ -376,5 +376,5 @@ break; default: - _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type)); + _error_("analysis %i (%s) not supported yet",analysis_type,EnumToStringx(analysis_type)); } Index: /issm/trunk/src/c/objects/Loads/Pengrid.cpp =================================================================== --- /issm/trunk/src/c/objects/Loads/Pengrid.cpp (revision 8223) +++ /issm/trunk/src/c/objects/Loads/Pengrid.cpp (revision 8224) @@ -104,5 +104,5 @@ printf("Pengrid:\n"); printf(" id: %i\n",id); - printf(" analysis_type: %s\n",EnumToString(analysis_type)); + printf(" analysis_type: %s\n",EnumToStringx(analysis_type)); hnode->DeepEcho(); helement->DeepEcho(); @@ -320,5 +320,5 @@ break; default: - _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type)); + _error_("analysis %i (%s) not supported yet",analysis_type,EnumToStringx(analysis_type)); } @@ -348,5 +348,5 @@ break; default: - _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type)); + _error_("analysis %i (%s) not supported yet",analysis_type,EnumToStringx(analysis_type)); } @@ -451,5 +451,5 @@ } else{ - _error_("analysis: %s not supported yet",EnumToString(analysis_type)); + _error_("analysis: %s not supported yet",EnumToStringx(analysis_type)); } Index: /issm/trunk/src/c/objects/Loads/Penpair.cpp =================================================================== --- /issm/trunk/src/c/objects/Loads/Penpair.cpp (revision 8223) +++ /issm/trunk/src/c/objects/Loads/Penpair.cpp (revision 8224) @@ -59,5 +59,5 @@ printf("Penpair:\n"); printf(" id: %i\n",id); - printf(" analysis_type: %s\n",EnumToString(analysis_type)); + printf(" analysis_type: %s\n",EnumToStringx(analysis_type)); hnodes->Echo(); @@ -70,5 +70,5 @@ printf("Penpair:\n"); printf(" id: %i\n",id); - printf(" analysis_type: %s\n",EnumToString(analysis_type)); + printf(" analysis_type: %s\n",EnumToStringx(analysis_type)); hnodes->DeepEcho(); @@ -228,5 +228,5 @@ break; default: - _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type)); + _error_("analysis %i (%s) not supported yet",analysis_type,EnumToStringx(analysis_type)); } Index: /issm/trunk/src/c/objects/Loads/Riftfront.cpp =================================================================== --- /issm/trunk/src/c/objects/Loads/Riftfront.cpp (revision 8223) +++ /issm/trunk/src/c/objects/Loads/Riftfront.cpp (revision 8224) @@ -139,5 +139,5 @@ printf("Riftfront:\n"); printf(" id: %i\n",id); - printf(" analysis_type: %s\n",EnumToString(analysis_type)); + printf(" analysis_type: %s\n",EnumToStringx(analysis_type)); printf(" hnodes: %p\n",hnodes); printf(" helements: %p\n",helements); @@ -167,5 +167,5 @@ printf("Riftfront:\n"); printf(" id: %i\n",id); - printf(" analysis_type: %s\n",EnumToString(analysis_type)); + printf(" analysis_type: %s\n",EnumToStringx(analysis_type)); hnodes->DeepEcho(); helements->DeepEcho(); @@ -435,5 +435,5 @@ break; default: - _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type)); + _error_("analysis %i (%s) not supported yet",analysis_type,EnumToStringx(analysis_type)); } @@ -461,5 +461,5 @@ break; default: - _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type)); + _error_("analysis %i (%s) not supported yet",analysis_type,EnumToStringx(analysis_type)); } Index: /issm/trunk/src/c/objects/Materials/Matice.cpp =================================================================== --- /issm/trunk/src/c/objects/Materials/Matice.cpp (revision 8223) +++ /issm/trunk/src/c/objects/Materials/Matice.cpp (revision 8224) @@ -521,7 +521,7 @@ return; - default: _error_("element %s not implemented yet",EnumToString(element->Enum())); - } - default: _error_("type %i (%s) not implemented yet",type,EnumToString(type)); + default: _error_("element %s not implemented yet",EnumToStringx(element->Enum())); + } + default: _error_("type %i (%s) not implemented yet",type,EnumToStringx(type)); } } @@ -561,7 +561,7 @@ return; - default: _error_("element %s not implemented yet",EnumToString(element->Enum())); - } - default: _error_("type %i (%s) not implemented yet",type,EnumToString(type)); + default: _error_("element %s not implemented yet",EnumToStringx(element->Enum())); + } + default: _error_("type %i (%s) not implemented yet",type,EnumToStringx(type)); } } Index: /issm/trunk/src/c/objects/Node.cpp =================================================================== --- /issm/trunk/src/c/objects/Node.cpp (revision 8223) +++ /issm/trunk/src/c/objects/Node.cpp (revision 8224) @@ -174,5 +174,5 @@ printf(" id: %i\n",id); printf(" sid: %i\n",sid); - printf(" analysis_type: %s\n",EnumToString(analysis_type)); + printf(" analysis_type: %s\n",EnumToStringx(analysis_type)); indexing.Echo(); printf(" hvertex: not displayed\n"); @@ -188,5 +188,5 @@ printf(" id: %i\n",id); printf(" sid: %i\n",sid); - printf(" analysis_type: %s\n",EnumToString(analysis_type)); + printf(" analysis_type: %s\n",EnumToStringx(analysis_type)); indexing.DeepEcho(); printf("Vertex:\n"); @@ -328,5 +328,5 @@ return indexing.sdoflist[dofindex]; } - else _error_("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!"); + else _error_("%s%s%s"," set of enum type ",EnumToStringx(setenum)," not supported yet!"); } @@ -400,5 +400,5 @@ else for(i=0;iindexing.ssize;i++) outdoflist[i]=indexing.sdoflist[i]; } - else _error_("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!"); + else _error_("%s%s%s"," set of enum type ",EnumToStringx(setenum)," not supported yet!"); } } @@ -440,5 +440,5 @@ } } - else _error_("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!"); + else _error_("%s%s%s"," set of enum type ",EnumToStringx(setenum)," not supported yet!"); } else{ @@ -509,5 +509,5 @@ } } - else _error_("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!"); + else _error_("%s%s%s"," set of enum type ",EnumToStringx(setenum)," not supported yet!"); } } @@ -668,5 +668,5 @@ else if (setenum==FsetEnum) numdofs=this->indexing.fsize; else if (setenum==SsetEnum) numdofs=this->indexing.ssize; - else _error_("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!"); + else _error_("%s%s%s"," set of enum type ",EnumToStringx(setenum)," not supported yet!"); } else{ @@ -698,5 +698,5 @@ else numdofs=this->indexing.ssize; } - else _error_("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!"); + else _error_("%s%s%s"," set of enum type ",EnumToStringx(setenum)," not supported yet!"); } return numdofs; @@ -881,5 +881,5 @@ dofcount+=this->indexing.ssize; } - else _error_("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!"); + else _error_("%s%s%s"," set of enum type ",EnumToStringx(setenum)," not supported yet!"); @@ -910,5 +910,5 @@ for(i=0;iindexing.ssize;i++) indexing.sdoflist[i]+=dofcount; } - else _error_("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!"); + else _error_("%s%s%s"," set of enum type ",EnumToStringx(setenum)," not supported yet!"); } /*}}}*/ @@ -926,5 +926,5 @@ else if(setenum==FsetEnum)for(j=0;jindexing.fsize;j++) *(truedofs+ncols*sid+j)=indexing.fdoflist[j]; else if(setenum==SsetEnum)for(j=0;jindexing.ssize;j++) *(truedofs+ncols*sid+j)=indexing.sdoflist[j]; - else _error_("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!"); + else _error_("%s%s%s"," set of enum type ",EnumToStringx(setenum)," not supported yet!"); } @@ -945,5 +945,5 @@ else if(setenum==FsetEnum)for(j=0;jindexing.fsize;j++) indexing.fdoflist[j]=*(alltruedofs+ncols*sid+j); else if(setenum==SsetEnum)for(j=0;jindexing.ssize;j++) indexing.sdoflist[j]=*(alltruedofs+ncols*sid+j); - else _error_("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!"); + else _error_("%s%s%s"," set of enum type ",EnumToStringx(setenum)," not supported yet!"); } Index: /issm/trunk/src/c/objects/Params/BoolParam.cpp =================================================================== --- /issm/trunk/src/c/objects/Params/BoolParam.cpp (revision 8223) +++ /issm/trunk/src/c/objects/Params/BoolParam.cpp (revision 8224) @@ -49,5 +49,5 @@ printf("BoolParam:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type)); printf(" value: %s\n",this->value?"true":"false"); } @@ -129,5 +129,5 @@ /*FUNCTION BoolParam::GetParameterName{{{1*/ char* BoolParam::GetParameterName(void){ - return EnumToString(this->enum_type); + return EnumToStringx(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/Params/BoolParam.h =================================================================== --- /issm/trunk/src/c/objects/Params/BoolParam.h (revision 8223) +++ /issm/trunk/src/c/objects/Params/BoolParam.h (revision 8224) @@ -50,28 +50,28 @@ int EnumType(){return enum_type;} void GetParameterValue(bool* pbool){*pbool=value;} - void GetParameterValue(int* pinteger){_error_("Bool param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));} - void GetParameterValue(int** pintarray,int* pM){_error_("Bool param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));} - void GetParameterValue(double* pdouble){_error_("Bool param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));} - void GetParameterValue(char** pstring){_error_("Bool param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));} - void GetParameterValue(char*** pstringarray,int* pM){_error_("Bool param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM){_error_("Bool param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM, int* pN){_error_("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){_error_("Bool param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));} - void GetParameterValue(Vec* pvec){_error_("Bool param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));} - void GetParameterValue(Mat* pmat){_error_("Bool param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));} - void GetParameterValue(FILE** pfid){_error_("Bool param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));} + void GetParameterValue(int* pinteger){_error_("Bool param of enum %i (%s) cannot return an integer",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(int** pintarray,int* pM){_error_("Bool param of enum %i (%s) cannot return an array of integers",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double* pdouble){_error_("Bool param of enum %i (%s) cannot return a double",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(char** pstring){_error_("Bool param of enum %i (%s) cannot return a string",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(char*** pstringarray,int* pM){_error_("Bool param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM){_error_("Bool param of enum %i (%s) cannot return a double array",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM, int* pN){_error_("Bool param of enum %i (%s) cannot return a double array",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){_error_("Bool param of enum %i (%s) cannot return a matrix array",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(Vec* pvec){_error_("Bool param of enum %i (%s) cannot return a Vec",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(Mat* pmat){_error_("Bool param of enum %i (%s) cannot return a Mat",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(FILE** pfid){_error_("Bool param of enum %i (%s) cannot return a FILE",enum_type,EnumToStringx(enum_type));} void SetValue(bool boolean){this->value=boolean;} void SetValue(int integer){this->value=(bool)integer;} - void SetValue(int* intarray,int M){_error_("Bool param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));} + void SetValue(int* intarray,int M){_error_("Bool param of enum %i (%s) cannot hold an int array",enum_type,EnumToStringx(enum_type));} void SetValue(double scalar){this->value=(bool)scalar;} - void SetValue(char* string){_error_("Bool param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));} - void SetValue(char** stringarray,int M){_error_("Bool param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));} - void SetValue(double* doublearray,int M){_error_("Bool param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));} - void SetValue(double* pdoublearray,int M,int N){_error_("Bool param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));} - void SetValue(Vec vec){_error_("Bool param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));} - void SetValue(Mat mat){_error_("Bool param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));} - void SetValue(FILE* fid){_error_("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){_error_("Bool param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));} + void SetValue(char* string){_error_("Bool param of enum %i (%s) cannot hold a string",enum_type,EnumToStringx(enum_type));} + void SetValue(char** stringarray,int M){_error_("Bool param of enum %i (%s) cannot hold a string array",enum_type,EnumToStringx(enum_type));} + void SetValue(double* doublearray,int M){_error_("Bool param of enum %i (%s) cannot hold a double array",enum_type,EnumToStringx(enum_type));} + void SetValue(double* pdoublearray,int M,int N){_error_("Bool param of enum %i (%s) cannot hold a double array",enum_type,EnumToStringx(enum_type));} + void SetValue(Vec vec){_error_("Bool param of enum %i (%s) cannot hold a Vec",enum_type,EnumToStringx(enum_type));} + void SetValue(Mat mat){_error_("Bool param of enum %i (%s) cannot hold a Mat",enum_type,EnumToStringx(enum_type));} + void SetValue(FILE* fid){_error_("Bool param of enum %i (%s) cannot hold a FILE",enum_type,EnumToStringx(enum_type));} + void SetValue(double** array, int M, int* mdim_array, int* ndim_array){_error_("Bool param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToStringx(enum_type));} char* GetParameterName(void); Index: /issm/trunk/src/c/objects/Params/DoubleMatArrayParam.cpp =================================================================== --- /issm/trunk/src/c/objects/Params/DoubleMatArrayParam.cpp (revision 8223) +++ /issm/trunk/src/c/objects/Params/DoubleMatArrayParam.cpp (revision 8224) @@ -88,5 +88,5 @@ printf("DoubleMatArrayParam:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(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,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type)); printf(" array size: %i\n",this->M); for(i=0;ienum_type); + return EnumToStringx(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/Params/DoubleMatArrayParam.h =================================================================== --- /issm/trunk/src/c/objects/Params/DoubleMatArrayParam.h (revision 8223) +++ /issm/trunk/src/c/objects/Params/DoubleMatArrayParam.h (revision 8224) @@ -52,28 +52,28 @@ /*Param vritual function definitions: {{{1*/ int EnumType(){return enum_type;} - void GetParameterValue(bool* pbool){_error_("DoubleMatArray param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));} - void GetParameterValue(int* pinteger){_error_("DoubleMatArray param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));} - void GetParameterValue(int** pintarray,int* pM){_error_("DoubleMatArray param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));} - void GetParameterValue(double* pdouble){_error_("DoubleMatArray param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));} - void GetParameterValue(char** pstring){_error_("DoubleMatArray param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));} - void GetParameterValue(char*** pstringarray,int* pM){_error_("DoubleMatArray param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM){_error_("DoubleMatArray param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM, int* pN){_error_("DoubleMatArray param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));} + void GetParameterValue(bool* pbool){_error_("DoubleMatArray param of enum %i (%s) cannot return a bool",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(int* pinteger){_error_("DoubleMatArray param of enum %i (%s) cannot return an integer",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(int** pintarray,int* pM){_error_("DoubleMatArray param of enum %i (%s) cannot return an array of integers",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double* pdouble){_error_("DoubleMatArray param of enum %i (%s) cannot return a double",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(char** pstring){_error_("DoubleMatArray param of enum %i (%s) cannot return a string",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(char*** pstringarray,int* pM){_error_("DoubleMatArray param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM){_error_("DoubleMatArray param of enum %i (%s) cannot return a double array",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM, int* pN){_error_("DoubleMatArray param of enum %i (%s) cannot return a double array",enum_type,EnumToStringx(enum_type));} void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims); - void GetParameterValue(Vec* pvec){_error_("DoubleMatArray param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));} - void GetParameterValue(Mat* pmat){_error_("DoubleMatArray param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));} - void GetParameterValue(FILE** pfid){_error_("DoubleMatArray param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));} + void GetParameterValue(Vec* pvec){_error_("DoubleMatArray param of enum %i (%s) cannot return a Vec",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(Mat* pmat){_error_("DoubleMatArray param of enum %i (%s) cannot return a Mat",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(FILE** pfid){_error_("DoubleMatArray param of enum %i (%s) cannot return a FILE",enum_type,EnumToStringx(enum_type));} - void SetValue(bool boolean){_error_("DoubleMatArray param of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));} - void SetValue(int integer){_error_("DoubleMatArray param of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));} - void SetValue(int* intarray,int M){_error_("DoubleMatArray param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));} - void SetValue(double scalar){_error_("DoubleMatArray param of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));} - void SetValue(char* string){_error_("DoubleMatArray param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));} - void SetValue(char** stringarray,int M){_error_("DoubleMatArray param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));} - void SetValue(double* doublearray,int M){_error_("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){_error_("DoubleMatArray param of enum %i (%s) cannot hold a double mat array",enum_type,EnumToString(enum_type));} - void SetValue(Vec vec){_error_("DoubleMatArray param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));} - void SetValue(Mat mat){_error_("DoubleMatArray param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));} - void SetValue(FILE* fid){_error_("Bool param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));} + void SetValue(bool boolean){_error_("DoubleMatArray param of enum %i (%s) cannot hold a boolean",enum_type,EnumToStringx(enum_type));} + void SetValue(int integer){_error_("DoubleMatArray param of enum %i (%s) cannot hold an integer",enum_type,EnumToStringx(enum_type));} + void SetValue(int* intarray,int M){_error_("DoubleMatArray param of enum %i (%s) cannot hold an int array",enum_type,EnumToStringx(enum_type));} + void SetValue(double scalar){_error_("DoubleMatArray param of enum %i (%s) cannot hold a scalar",enum_type,EnumToStringx(enum_type));} + void SetValue(char* string){_error_("DoubleMatArray param of enum %i (%s) cannot hold a string",enum_type,EnumToStringx(enum_type));} + void SetValue(char** stringarray,int M){_error_("DoubleMatArray param of enum %i (%s) cannot hold a string array",enum_type,EnumToStringx(enum_type));} + void SetValue(double* doublearray,int M){_error_("DoubleMatArray param of enum %i (%s) cannot hold a double vec array",enum_type,EnumToStringx(enum_type));} + void SetValue(double* doublearray,int M,int N){_error_("DoubleMatArray param of enum %i (%s) cannot hold a double mat array",enum_type,EnumToStringx(enum_type));} + void SetValue(Vec vec){_error_("DoubleMatArray param of enum %i (%s) cannot hold a Vec",enum_type,EnumToStringx(enum_type));} + void SetValue(Mat mat){_error_("DoubleMatArray param of enum %i (%s) cannot hold a Mat",enum_type,EnumToStringx(enum_type));} + void SetValue(FILE* fid){_error_("Bool param of enum %i (%s) cannot hold a FILE",enum_type,EnumToStringx(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 8223) +++ /issm/trunk/src/c/objects/Params/DoubleMatParam.cpp (revision 8224) @@ -49,5 +49,5 @@ printf("DoubleMatParam:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(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,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type)); printf(" matrix size: %ix%i\n",this->M,this->N); for(i=0;iM;i++){ @@ -167,5 +167,5 @@ /*FUNCTION DoubleMatParam::GetParameterName{{{1*/ char* DoubleMatParam::GetParameterName(void){ - return EnumToString(this->enum_type); + return EnumToStringx(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/Params/DoubleMatParam.h =================================================================== --- /issm/trunk/src/c/objects/Params/DoubleMatParam.h (revision 8223) +++ /issm/trunk/src/c/objects/Params/DoubleMatParam.h (revision 8224) @@ -51,29 +51,29 @@ /*Param vritual function definitions: {{{1*/ int EnumType(){return enum_type;} - void GetParameterValue(bool* pbool){_error_("DoubleMat param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));} - void GetParameterValue(int* pinteger){_error_("DoubleMat param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));} - void GetParameterValue(int** pintarray,int* pM){_error_("DoubleMat param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));} - void GetParameterValue(double* pdouble){_error_("DoubleMat param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));} - void GetParameterValue(char** pstring){_error_("DoubleMat param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));} - void GetParameterValue(char*** pstringarray,int* pM){_error_("DoubleMat param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM){_error_("DoubleMat param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));} + void GetParameterValue(bool* pbool){_error_("DoubleMat param of enum %i (%s) cannot return a bool",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(int* pinteger){_error_("DoubleMat param of enum %i (%s) cannot return an integer",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(int** pintarray,int* pM){_error_("DoubleMat param of enum %i (%s) cannot return an array of integers",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double* pdouble){_error_("DoubleMat param of enum %i (%s) cannot return a double",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(char** pstring){_error_("DoubleMat param of enum %i (%s) cannot return a string",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(char*** pstringarray,int* pM){_error_("DoubleMat param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM){_error_("DoubleMat param of enum %i (%s) cannot return a double array",enum_type,EnumToStringx(enum_type));} void GetParameterValue(double** pdoublearray,int* pM,int* pN); - void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){_error_("DoubleMat param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));} - void GetParameterValue(Vec* pvec){_error_("DoubleMat param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));} - void GetParameterValue(Mat* pmat){_error_("DoubleMat param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));} - void GetParameterValue(FILE** pfid){_error_("DoubleMat param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));} + void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){_error_("DoubleMat param of enum %i (%s) cannot return a matrix array",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(Vec* pvec){_error_("DoubleMat param of enum %i (%s) cannot return a Vec",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(Mat* pmat){_error_("DoubleMat param of enum %i (%s) cannot return a Mat",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(FILE** pfid){_error_("DoubleMat param of enum %i (%s) cannot return a FILE",enum_type,EnumToStringx(enum_type));} - void SetValue(bool boolean){_error_("DoubleMat param of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));} - void SetValue(int integer){_error_("DoubleMat param of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));} - void SetValue(int* intarray,int M){_error_("DoubleMat param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));} - void SetValue(double scalar){_error_("DoubleMat param of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));} - void SetValue(char* string){_error_("DoubleMat param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));} - void SetValue(char** stringarray,int M){_error_("DoubleMat param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));} - void SetValue(double* doublearray,int M){_error_("DoubleMat param of enum %i (%s) cannot hold a double vec array",enum_type,EnumToString(enum_type));} + void SetValue(bool boolean){_error_("DoubleMat param of enum %i (%s) cannot hold a boolean",enum_type,EnumToStringx(enum_type));} + void SetValue(int integer){_error_("DoubleMat param of enum %i (%s) cannot hold an integer",enum_type,EnumToStringx(enum_type));} + void SetValue(int* intarray,int M){_error_("DoubleMat param of enum %i (%s) cannot hold an int array",enum_type,EnumToStringx(enum_type));} + void SetValue(double scalar){_error_("DoubleMat param of enum %i (%s) cannot hold a scalar",enum_type,EnumToStringx(enum_type));} + void SetValue(char* string){_error_("DoubleMat param of enum %i (%s) cannot hold a string",enum_type,EnumToStringx(enum_type));} + void SetValue(char** stringarray,int M){_error_("DoubleMat param of enum %i (%s) cannot hold a string array",enum_type,EnumToStringx(enum_type));} + void SetValue(double* doublearray,int M){_error_("DoubleMat param of enum %i (%s) cannot hold a double vec array",enum_type,EnumToStringx(enum_type));} void SetValue(double* doublearray,int M,int N); - void SetValue(Vec vec){_error_("DoubleMat param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));} - void SetValue(Mat mat){_error_("DoubleMat param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));} - void SetValue(FILE* fid){_error_("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){_error_("DoubleMat param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));} + void SetValue(Vec vec){_error_("DoubleMat param of enum %i (%s) cannot hold a Vec",enum_type,EnumToStringx(enum_type));} + void SetValue(Mat mat){_error_("DoubleMat param of enum %i (%s) cannot hold a Mat",enum_type,EnumToStringx(enum_type));} + void SetValue(FILE* fid){_error_("DoubleMat param of enum %i (%s) cannot hold a FILE",enum_type,EnumToStringx(enum_type));} + void SetValue(double** array, int M, int* mdim_array, int* ndim_array){_error_("DoubleMat param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToStringx(enum_type));} char* GetParameterName(void); Index: /issm/trunk/src/c/objects/Params/DoubleParam.cpp =================================================================== --- /issm/trunk/src/c/objects/Params/DoubleParam.cpp (revision 8223) +++ /issm/trunk/src/c/objects/Params/DoubleParam.cpp (revision 8224) @@ -46,5 +46,5 @@ printf("DoubleParam:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type)); printf(" value: %g\n",this->value); } @@ -126,5 +126,5 @@ /*FUNCTION DoubleParam::GetParameterName{{{1*/ char* DoubleParam::GetParameterName(void){ - return EnumToString(this->enum_type); + return EnumToStringx(this->enum_type); } /*}}}*/ @@ -134,5 +134,5 @@ *pinteger=(int)value; #else - _error_("Double param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type)); + _error_("Double param of enum %i (%s) cannot return an integer",enum_type,EnumToStringx(enum_type)); #endif } @@ -147,5 +147,5 @@ #else - _error_("Double param of enum %i (%s) cannot return an bool",enum_type,EnumToString(enum_type)); + _error_("Double param of enum %i (%s) cannot return an bool",enum_type,EnumToStringx(enum_type)); #endif } @@ -163,5 +163,5 @@ *pintarray=output; #else - _error_("Double param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type)); + _error_("Double param of enum %i (%s) cannot return an array of integers",enum_type,EnumToStringx(enum_type)); #endif } @@ -179,5 +179,5 @@ *pdoublearray=output; #else - _error_("Double param of enum %i (%s) cannot return an array of double",enum_type,EnumToString(enum_type)); + _error_("Double param of enum %i (%s) cannot return an array of double",enum_type,EnumToStringx(enum_type)); #endif } @@ -196,5 +196,5 @@ *pdoublearray=output; #else - _error_("Double param of enum %i (%s) cannot return an array of double",enum_type,EnumToString(enum_type)); + _error_("Double param of enum %i (%s) cannot return an array of double",enum_type,EnumToStringx(enum_type)); #endif } Index: /issm/trunk/src/c/objects/Params/DoubleParam.h =================================================================== --- /issm/trunk/src/c/objects/Params/DoubleParam.h (revision 8223) +++ /issm/trunk/src/c/objects/Params/DoubleParam.h (revision 8224) @@ -54,25 +54,25 @@ void GetParameterValue(int** pintarray,int* pM); void GetParameterValue(double* pdouble){*pdouble=value;} - void GetParameterValue(char** pstring){_error_("Double param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));} - void GetParameterValue(char*** pstringarray,int* pM){_error_("Double param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));} + void GetParameterValue(char** pstring){_error_("Double param of enum %i (%s) cannot return a string",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(char*** pstringarray,int* pM){_error_("Double param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToStringx(enum_type));} void GetParameterValue(double** pdoublearray,int* pM); void GetParameterValue(double** pdoublearray,int* pM, int* pN); - void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){_error_("Double param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));} - void GetParameterValue(Vec* pvec){_error_("Double param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));} - void GetParameterValue(Mat* pmat){_error_("Double param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));} - void GetParameterValue(FILE** pfid){_error_("Double param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));} + void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){_error_("Double param of enum %i (%s) cannot return a matrix array",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(Vec* pvec){_error_("Double param of enum %i (%s) cannot return a Vec",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(Mat* pmat){_error_("Double param of enum %i (%s) cannot return a Mat",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(FILE** pfid){_error_("Double param of enum %i (%s) cannot return a FILE",enum_type,EnumToStringx(enum_type));} void SetValue(bool boolean){this->value=(double)boolean;} void SetValue(int integer){this->value=(double)integer;} - void SetValue(int* intarray,int M){_error_("Double param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));} + void SetValue(int* intarray,int M){_error_("Double param of enum %i (%s) cannot hold an int array",enum_type,EnumToStringx(enum_type));} void SetValue(double scalar){this->value=(double)scalar;} - void SetValue(char* string){_error_("Double param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));} - void SetValue(char** stringarray,int M){_error_("Double param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));} - void SetValue(double* doublearray,int M){_error_("Double param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));} - void SetValue(double* pdoublearray,int M,int N){_error_("Double param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));} - void SetValue(Vec vec){_error_("Double param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));} - void SetValue(Mat mat){_error_("Double param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));} - void SetValue(FILE* fid){_error_("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){_error_("Double param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));} + void SetValue(char* string){_error_("Double param of enum %i (%s) cannot hold a string",enum_type,EnumToStringx(enum_type));} + void SetValue(char** stringarray,int M){_error_("Double param of enum %i (%s) cannot hold a string array",enum_type,EnumToStringx(enum_type));} + void SetValue(double* doublearray,int M){_error_("Double param of enum %i (%s) cannot hold a double array",enum_type,EnumToStringx(enum_type));} + void SetValue(double* pdoublearray,int M,int N){_error_("Double param of enum %i (%s) cannot hold a double array",enum_type,EnumToStringx(enum_type));} + void SetValue(Vec vec){_error_("Double param of enum %i (%s) cannot hold a Vec",enum_type,EnumToStringx(enum_type));} + void SetValue(Mat mat){_error_("Double param of enum %i (%s) cannot hold a Mat",enum_type,EnumToStringx(enum_type));} + void SetValue(FILE* fid){_error_("Double param of enum %i (%s) cannot hold a FILE",enum_type,EnumToStringx(enum_type));} + void SetValue(double** array, int M, int* mdim_array, int* ndim_array){_error_("Double param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToStringx(enum_type));} char* GetParameterName(void); Index: /issm/trunk/src/c/objects/Params/DoubleVecParam.cpp =================================================================== --- /issm/trunk/src/c/objects/Params/DoubleVecParam.cpp (revision 8223) +++ /issm/trunk/src/c/objects/Params/DoubleVecParam.cpp (revision 8224) @@ -48,5 +48,5 @@ printf("DoubleVecParam:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(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,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type)); printf(" vector size: %i\n",this->M); for(i=0;iM;i++){ @@ -174,5 +174,5 @@ *pintarray=output; #else - _error_("Double param of enum %i (%s) cannot return an array of double",enum_type,EnumToString(enum_type)); + _error_("Double param of enum %i (%s) cannot return an array of double",enum_type,EnumToStringx(enum_type)); #endif } @@ -180,5 +180,5 @@ /*FUNCTION DoubleVecParam::GetParameterName{{{1*/ char* DoubleVecParam::GetParameterName(void){ - return EnumToString(this->enum_type); + return EnumToStringx(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/Params/DoubleVecParam.h =================================================================== --- /issm/trunk/src/c/objects/Params/DoubleVecParam.h (revision 8223) +++ /issm/trunk/src/c/objects/Params/DoubleVecParam.h (revision 8224) @@ -50,29 +50,29 @@ /*Param virtual functions definitions: {{{1*/ int EnumType(){return enum_type;} - void GetParameterValue(bool* pbool){_error_("DoubleVec param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));} - void GetParameterValue(int* pinteger){_error_("DoubleVec param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));} + void GetParameterValue(bool* pbool){_error_("DoubleVec param of enum %i (%s) cannot return a bool",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(int* pinteger){_error_("DoubleVec param of enum %i (%s) cannot return an integer",enum_type,EnumToStringx(enum_type));} void GetParameterValue(int** pintarray,int* pM); - void GetParameterValue(double* pdouble){_error_("DoubleVec param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));} - void GetParameterValue(char** pstring){_error_("DoubleVec param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));} - void GetParameterValue(char*** pstringarray,int* pM){_error_("DoubleVec param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));} + void GetParameterValue(double* pdouble){_error_("DoubleVec param of enum %i (%s) cannot return a double",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(char** pstring){_error_("DoubleVec param of enum %i (%s) cannot return a string",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(char*** pstringarray,int* pM){_error_("DoubleVec param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToStringx(enum_type));} void GetParameterValue(double** pdoublearray,int* pM); - void GetParameterValue(double** pdoublearray,int* pM, int* pN){_error_("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){_error_("DoubleVec param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));} - void GetParameterValue(Vec* pvec){_error_("DoubleVec param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));} - void GetParameterValue(Mat* pmat){_error_("DoubleVec param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));} - void GetParameterValue(FILE** pfid){_error_("DoubleVec param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM, int* pN){_error_("DoubleVec param of enum %i (%s) cannot return a double array",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){_error_("DoubleVec param of enum %i (%s) cannot return a matrix array",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(Vec* pvec){_error_("DoubleVec param of enum %i (%s) cannot return a Vec",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(Mat* pmat){_error_("DoubleVec param of enum %i (%s) cannot return a Mat",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(FILE** pfid){_error_("DoubleVec param of enum %i (%s) cannot return a FILE",enum_type,EnumToStringx(enum_type));} - void SetValue(bool boolean){_error_("DoubleVec param of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));} - void SetValue(int integer){_error_("DoubleVec param of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));} - void SetValue(int* intarray,int M){_error_("DoubleVec param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));} - void SetValue(double scalar){_error_("DoubleVec param of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));} - void SetValue(char* string){_error_("DoubleVec param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));} - void SetValue(char** stringarray,int M){_error_("DoubleVec param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));} + void SetValue(bool boolean){_error_("DoubleVec param of enum %i (%s) cannot hold a boolean",enum_type,EnumToStringx(enum_type));} + void SetValue(int integer){_error_("DoubleVec param of enum %i (%s) cannot hold an integer",enum_type,EnumToStringx(enum_type));} + void SetValue(int* intarray,int M){_error_("DoubleVec param of enum %i (%s) cannot hold an int array",enum_type,EnumToStringx(enum_type));} + void SetValue(double scalar){_error_("DoubleVec param of enum %i (%s) cannot hold a scalar",enum_type,EnumToStringx(enum_type));} + void SetValue(char* string){_error_("DoubleVec param of enum %i (%s) cannot hold a string",enum_type,EnumToStringx(enum_type));} + void SetValue(char** stringarray,int M){_error_("DoubleVec param of enum %i (%s) cannot hold a string array",enum_type,EnumToStringx(enum_type));} void SetValue(double* doublearray,int M); - void SetValue(double* pdoublearray,int M,int N){_error_("DoubleVec param of enum %i (%s) cannot hold a double mat array",enum_type,EnumToString(enum_type));} - void SetValue(Vec vec){_error_("DoubleVec param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));} - void SetValue(Mat mat){_error_("DoubleVec param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));} - void SetValue(FILE* fid){_error_("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){_error_("DoubleVec param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));} + void SetValue(double* pdoublearray,int M,int N){_error_("DoubleVec param of enum %i (%s) cannot hold a double mat array",enum_type,EnumToStringx(enum_type));} + void SetValue(Vec vec){_error_("DoubleVec param of enum %i (%s) cannot hold a Vec",enum_type,EnumToStringx(enum_type));} + void SetValue(Mat mat){_error_("DoubleVec param of enum %i (%s) cannot hold a Mat",enum_type,EnumToStringx(enum_type));} + void SetValue(FILE* fid){_error_("DoubleVec param of enum %i (%s) cannot hold a FILE",enum_type,EnumToStringx(enum_type));} + void SetValue(double** array, int M, int* mdim_array, int* ndim_array){_error_("DoubleVec param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToStringx(enum_type));} char* GetParameterName(void); Index: /issm/trunk/src/c/objects/Params/FileParam.cpp =================================================================== --- /issm/trunk/src/c/objects/Params/FileParam.cpp (revision 8223) +++ /issm/trunk/src/c/objects/Params/FileParam.cpp (revision 8224) @@ -49,5 +49,5 @@ printf("FileParam:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type)); printf(" value: %p\n",this->value); } @@ -96,5 +96,5 @@ /*FUNCTION FileParam::GetParameterName{{{1*/ char* FileParam::GetParameterName(void){ - return EnumToString(this->enum_type); + return EnumToStringx(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/Params/FileParam.h =================================================================== --- /issm/trunk/src/c/objects/Params/FileParam.h (revision 8223) +++ /issm/trunk/src/c/objects/Params/FileParam.h (revision 8224) @@ -49,29 +49,29 @@ /*Param vritual function definitions: {{{1*/ int EnumType(){return enum_type;} - void GetParameterValue(bool* pbool){ _error_("FileParam of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));} - void GetParameterValue(int* pinteger){_error_("FileParam of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));} - void GetParameterValue(int** pintarray,int* pM){_error_("FileParam of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));} - void GetParameterValue(double* pdouble){_error_("FileParam of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));} - void GetParameterValue(char** pstring){_error_("FileParam of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));} - void GetParameterValue(char*** pstringarray,int* pM){_error_("FileParam of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM){_error_("FileParam of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM, int* pN){_error_("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){_error_("File param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));} - void GetParameterValue(Vec* pvec){_error_("FileParam of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));} - void GetParameterValue(Mat* pmat){_error_("FileParam of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));} + void GetParameterValue(bool* pbool){ _error_("FileParam of enum %i (%s) cannot return a bool",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(int* pinteger){_error_("FileParam of enum %i (%s) cannot return a double",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(int** pintarray,int* pM){_error_("FileParam of enum %i (%s) cannot return a double",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double* pdouble){_error_("FileParam of enum %i (%s) cannot return a double",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(char** pstring){_error_("FileParam of enum %i (%s) cannot return a string",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(char*** pstringarray,int* pM){_error_("FileParam of enum %i (%s) cannot return a string arrayl",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM){_error_("FileParam of enum %i (%s) cannot return a double array",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM, int* pN){_error_("FileParam of enum %i (%s) cannot return a double array",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){_error_("File param of enum %i (%s) cannot return a matrix array",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(Vec* pvec){_error_("FileParam of enum %i (%s) cannot return a Vec",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(Mat* pmat){_error_("FileParam of enum %i (%s) cannot return a Mat",enum_type,EnumToStringx(enum_type));} void GetParameterValue(FILE** pfid){*pfid=value;}; - void SetValue(bool boolean){_error_("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));} - void SetValue(int integer){_error_("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));} - void SetValue(int* intarray,int M){_error_("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));} - void SetValue(double scalar){_error_("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));} - void SetValue(char* string){_error_("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));} - void SetValue(char** stringarray,int M){_error_("FileParam of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));} - void SetValue(double* doublearray,int M){_error_("FileParam of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));} - void SetValue(double* pdoublearray,int M,int N){_error_("FileParam of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));} - void SetValue(Vec vec){_error_("FileParam of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));} - void SetValue(Mat mat){_error_("FileParam of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));} - void SetValue(FILE* fid){_error_("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){_error_("File param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));} + void SetValue(bool boolean){_error_("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumToStringx(enum_type));} + void SetValue(int integer){_error_("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumToStringx(enum_type));} + void SetValue(int* intarray,int M){_error_("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumToStringx(enum_type));} + void SetValue(double scalar){_error_("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumToStringx(enum_type));} + void SetValue(char* string){_error_("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumToStringx(enum_type));} + void SetValue(char** stringarray,int M){_error_("FileParam of enum %i (%s) cannot hold a string array",enum_type,EnumToStringx(enum_type));} + void SetValue(double* doublearray,int M){_error_("FileParam of enum %i (%s) cannot hold a double array",enum_type,EnumToStringx(enum_type));} + void SetValue(double* pdoublearray,int M,int N){_error_("FileParam of enum %i (%s) cannot hold a double array",enum_type,EnumToStringx(enum_type));} + void SetValue(Vec vec){_error_("FileParam of enum %i (%s) cannot hold a Vec",enum_type,EnumToStringx(enum_type));} + void SetValue(Mat mat){_error_("FileParam of enum %i (%s) cannot hold a Mat",enum_type,EnumToStringx(enum_type));} + void SetValue(FILE* fid){_error_("File param of enum %i (%s) cannot hold a FILE",enum_type,EnumToStringx(enum_type));} + void SetValue(double** array, int M, int* mdim_array, int* ndim_array){_error_("File param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToStringx(enum_type));} char* GetParameterName(void); Index: /issm/trunk/src/c/objects/Params/IntParam.cpp =================================================================== --- /issm/trunk/src/c/objects/Params/IntParam.cpp (revision 8223) +++ /issm/trunk/src/c/objects/Params/IntParam.cpp (revision 8224) @@ -49,5 +49,5 @@ printf("IntParam:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type)); printf(" value: %i\n",this->value); } @@ -129,5 +129,5 @@ /*FUNCTION IntParam::GetParameterName{{{1*/ char* IntParam::GetParameterName(void){ - return EnumToString(this->enum_type); + return EnumToStringx(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/Params/IntParam.h =================================================================== --- /issm/trunk/src/c/objects/Params/IntParam.h (revision 8223) +++ /issm/trunk/src/c/objects/Params/IntParam.h (revision 8224) @@ -50,29 +50,29 @@ /*Param vritual function definitions: {{{1*/ int EnumType(){return enum_type;} - void GetParameterValue(bool* pbool){_error_("Int param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));} + void GetParameterValue(bool* pbool){_error_("Int param of enum %i (%s) cannot return a bool",enum_type,EnumToStringx(enum_type));} void GetParameterValue(int* pinteger){*pinteger=value;} - void GetParameterValue(int** pintarray,int* pM){_error_("Int param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));} - void GetParameterValue(double* pdouble){_error_("Int param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));} - void GetParameterValue(char** pstring){_error_("Int param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));} - void GetParameterValue(char*** pstringarray,int* pM){_error_("Int param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM){_error_("Int param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM, int* pN){_error_("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){_error_("Int param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));} - void GetParameterValue(Vec* pvec){_error_("Int param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));} - void GetParameterValue(Mat* pmat){_error_("Int param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));} - void GetParameterValue(FILE** pfid){_error_("Int param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));} + void GetParameterValue(int** pintarray,int* pM){_error_("Int param of enum %i (%s) cannot return an array of integers",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double* pdouble){_error_("Int param of enum %i (%s) cannot return a double",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(char** pstring){_error_("Int param of enum %i (%s) cannot return a string",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(char*** pstringarray,int* pM){_error_("Int param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM){_error_("Int param of enum %i (%s) cannot return a double array",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM, int* pN){_error_("Int param of enum %i (%s) cannot return a double array",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){_error_("Int param of enum %i (%s) cannot return a matrix array",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(Vec* pvec){_error_("Int param of enum %i (%s) cannot return a Vec",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(Mat* pmat){_error_("Int param of enum %i (%s) cannot return a Mat",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(FILE** pfid){_error_("Int param of enum %i (%s) cannot return a FILE",enum_type,EnumToStringx(enum_type));} void SetValue(bool boolean){this->value=(int)boolean;} void SetValue(int integer){this->value=integer;} - void SetValue(int* intarray,int M){_error_("Int param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));} + void SetValue(int* intarray,int M){_error_("Int param of enum %i (%s) cannot hold an int array",enum_type,EnumToStringx(enum_type));} void SetValue(double scalar){this->value=(int)scalar;} - void SetValue(char* string){_error_("Int param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));} - void SetValue(char** stringarray,int M){_error_("Int param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));} - void SetValue(double* doublearray,int M){_error_("Int param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));} - void SetValue(double* pdoublearray,int M,int N){_error_("Int param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));} - void SetValue(Vec vec){_error_("Int param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));} - void SetValue(Mat mat){_error_("Int param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));} - void SetValue(FILE* fid){_error_("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){_error_("Int param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));} + void SetValue(char* string){_error_("Int param of enum %i (%s) cannot hold a string",enum_type,EnumToStringx(enum_type));} + void SetValue(char** stringarray,int M){_error_("Int param of enum %i (%s) cannot hold a string array",enum_type,EnumToStringx(enum_type));} + void SetValue(double* doublearray,int M){_error_("Int param of enum %i (%s) cannot hold a double array",enum_type,EnumToStringx(enum_type));} + void SetValue(double* pdoublearray,int M,int N){_error_("Int param of enum %i (%s) cannot hold a double array",enum_type,EnumToStringx(enum_type));} + void SetValue(Vec vec){_error_("Int param of enum %i (%s) cannot hold a Vec",enum_type,EnumToStringx(enum_type));} + void SetValue(Mat mat){_error_("Int param of enum %i (%s) cannot hold a Mat",enum_type,EnumToStringx(enum_type));} + void SetValue(FILE* fid){_error_("Int param of enum %i (%s) cannot hold a FILE",enum_type,EnumToStringx(enum_type));} + void SetValue(double** array, int M, int* mdim_array, int* ndim_array){_error_("Int param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToStringx(enum_type));} char* GetParameterName(void); Index: /issm/trunk/src/c/objects/Params/IntVecParam.cpp =================================================================== --- /issm/trunk/src/c/objects/Params/IntVecParam.cpp (revision 8223) +++ /issm/trunk/src/c/objects/Params/IntVecParam.cpp (revision 8224) @@ -58,5 +58,5 @@ printf("IntVecParam:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type)); printf(" vector size: %i\n",this->M); @@ -69,5 +69,5 @@ printf("IntVecParam:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type)); printf(" vector size: %i\n",this->M); for(i=0;iM;i++){ @@ -170,5 +170,5 @@ /*FUNCTION IntVecParam::GetParameterName{{{1*/ char* IntVecParam::GetParameterName(void){ - return EnumToString(this->enum_type); + return EnumToStringx(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/Params/IntVecParam.h =================================================================== --- /issm/trunk/src/c/objects/Params/IntVecParam.h (revision 8223) +++ /issm/trunk/src/c/objects/Params/IntVecParam.h (revision 8224) @@ -51,29 +51,29 @@ /*Param virtual functions definitions: {{{1*/ int EnumType(){return enum_type;} - void GetParameterValue(bool* pbool){_error_("IntVec param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));} - void GetParameterValue(int* pinteger){_error_("IntVec param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));} + void GetParameterValue(bool* pbool){_error_("IntVec param of enum %i (%s) cannot return a bool",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(int* pinteger){_error_("IntVec param of enum %i (%s) cannot return an integer",enum_type,EnumToStringx(enum_type));} void GetParameterValue(int** pintarray,int* pM); - void GetParameterValue(double* pdouble){_error_("IntVec param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));} - void GetParameterValue(char** pstring){_error_("IntVec param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));} - void GetParameterValue(char*** pstringarray,int* pM){_error_("IntVec param of enum %i (%s) cannot return a string array",enum_type,EnumToString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM){_error_("IntVec param of enum %i (%s) cannot return a double array (maybe in serial?)",enum_type,EnumToString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM, int* pN){_error_("IntVec 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){_error_("IntVec param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));} - void GetParameterValue(Vec* pvec){_error_("IntVec param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));} - void GetParameterValue(Mat* pmat){_error_("IntVec param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));} - void GetParameterValue(FILE** pfid){_error_("IntVec param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));} + void GetParameterValue(double* pdouble){_error_("IntVec param of enum %i (%s) cannot return a double",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(char** pstring){_error_("IntVec param of enum %i (%s) cannot return a string",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(char*** pstringarray,int* pM){_error_("IntVec param of enum %i (%s) cannot return a string array",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM){_error_("IntVec param of enum %i (%s) cannot return a double array (maybe in serial?)",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM, int* pN){_error_("IntVec param of enum %i (%s) cannot return a double array",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){_error_("IntVec param of enum %i (%s) cannot return a matrix array",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(Vec* pvec){_error_("IntVec param of enum %i (%s) cannot return a Vec",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(Mat* pmat){_error_("IntVec param of enum %i (%s) cannot return a Mat",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(FILE** pfid){_error_("IntVec param of enum %i (%s) cannot return a FILE",enum_type,EnumToStringx(enum_type));} - void SetValue(bool boolean){_error_("IntVec param of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));} - void SetValue(int integer){_error_("IntVec param of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));} + void SetValue(bool boolean){_error_("IntVec param of enum %i (%s) cannot hold a boolean",enum_type,EnumToStringx(enum_type));} + void SetValue(int integer){_error_("IntVec param of enum %i (%s) cannot hold an integer",enum_type,EnumToStringx(enum_type));} void SetValue(int* intarray,int M); - void SetValue(double scalar){_error_("IntVec param of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));} - void SetValue(char* string){_error_("IntVec param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));} - void SetValue(char** stringarray,int M){_error_("IntVec param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));} - void SetValue(double* doublearray,int M){_error_("IntVec param of enum %i (%s) cannot hold a double mat array",enum_type,EnumToString(enum_type));} - void SetValue(double* pdoublearray,int M,int N){_error_("IntVec param of enum %i (%s) cannot hold a double mat array",enum_type,EnumToString(enum_type));} - void SetValue(Vec vec){_error_("IntVec param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));} - void SetValue(Mat mat){_error_("IntVec param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));} - void SetValue(FILE* fid){_error_("IntVec 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){_error_("IntVec param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));} + void SetValue(double scalar){_error_("IntVec param of enum %i (%s) cannot hold a scalar",enum_type,EnumToStringx(enum_type));} + void SetValue(char* string){_error_("IntVec param of enum %i (%s) cannot hold a string",enum_type,EnumToStringx(enum_type));} + void SetValue(char** stringarray,int M){_error_("IntVec param of enum %i (%s) cannot hold a string array",enum_type,EnumToStringx(enum_type));} + void SetValue(double* doublearray,int M){_error_("IntVec param of enum %i (%s) cannot hold a double mat array",enum_type,EnumToStringx(enum_type));} + void SetValue(double* pdoublearray,int M,int N){_error_("IntVec param of enum %i (%s) cannot hold a double mat array",enum_type,EnumToStringx(enum_type));} + void SetValue(Vec vec){_error_("IntVec param of enum %i (%s) cannot hold a Vec",enum_type,EnumToStringx(enum_type));} + void SetValue(Mat mat){_error_("IntVec param of enum %i (%s) cannot hold a Mat",enum_type,EnumToStringx(enum_type));} + void SetValue(FILE* fid){_error_("IntVec param of enum %i (%s) cannot hold a FILE",enum_type,EnumToStringx(enum_type));} + void SetValue(double** array, int M, int* mdim_array, int* ndim_array){_error_("IntVec param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToStringx(enum_type));} char* GetParameterName(void); Index: /issm/trunk/src/c/objects/Params/PetscMatParam.cpp =================================================================== --- /issm/trunk/src/c/objects/Params/PetscMatParam.cpp (revision 8223) +++ /issm/trunk/src/c/objects/Params/PetscMatParam.cpp (revision 8224) @@ -49,5 +49,5 @@ printf("PetscMatParam:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type)); } @@ -58,5 +58,5 @@ int i; printf("PetscMatParam:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type)); MatView(value,PETSC_VIEWER_STDOUT_WORLD); } @@ -200,5 +200,5 @@ /*FUNCTION PetscMatParam::GetParameterName{{{1*/ char* PetscMatParam::GetParameterName(void){ - return EnumToString(this->enum_type); + return EnumToStringx(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/Params/PetscMatParam.h =================================================================== --- /issm/trunk/src/c/objects/Params/PetscMatParam.h (revision 8223) +++ /issm/trunk/src/c/objects/Params/PetscMatParam.h (revision 8224) @@ -50,29 +50,29 @@ /*Param vritual function definitions: {{{1*/ int EnumType(){return enum_type;} - void GetParameterValue(bool* pbool){_error_("PetscMat param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));} - void GetParameterValue(int* pinteger){_error_("PetscMat param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));} - void GetParameterValue(int** pintarray,int* pM){_error_("PetscMat param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));} - void GetParameterValue(double* pdouble){_error_("PetscMat param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));} - void GetParameterValue(char** pstring){_error_("PetscMat param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));} - void GetParameterValue(char*** pstringarray,int* pM){_error_("PetscMat param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM){_error_("PetscMat param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM, int* pN){_error_("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){_error_("PetscMat param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));} - void GetParameterValue(Vec* pvec){_error_("PetscMat param of enum %i (%s) cannot return a vec",enum_type,EnumToString(enum_type));} + void GetParameterValue(bool* pbool){_error_("PetscMat param of enum %i (%s) cannot return a bool",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(int* pinteger){_error_("PetscMat param of enum %i (%s) cannot return an integer",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(int** pintarray,int* pM){_error_("PetscMat param of enum %i (%s) cannot return an array of integers",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double* pdouble){_error_("PetscMat param of enum %i (%s) cannot return a double",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(char** pstring){_error_("PetscMat param of enum %i (%s) cannot return a string",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(char*** pstringarray,int* pM){_error_("PetscMat param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM){_error_("PetscMat param of enum %i (%s) cannot return a double array",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM, int* pN){_error_("PetscMat param of enum %i (%s) cannot return a double array",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){_error_("PetscMat param of enum %i (%s) cannot return a matrix array",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(Vec* pvec){_error_("PetscMat param of enum %i (%s) cannot return a vec",enum_type,EnumToStringx(enum_type));} void GetParameterValue(Mat* poutput); - void GetParameterValue(FILE** pfid){_error_("PetscMat param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));} + void GetParameterValue(FILE** pfid){_error_("PetscMat param of enum %i (%s) cannot return a FILE",enum_type,EnumToStringx(enum_type));} - void SetValue(bool boolean){_error_("PetscMat param of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));} - void SetValue(int integer){_error_("PetscMat param of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));} - void SetValue(int* intarray,int M){_error_("PetscMat param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));} - void SetValue(double scalar){_error_("PetscMat param of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));} - void SetValue(char* string){_error_("PetscMat param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));} - void SetValue(char** stringarray,int M){_error_("PetscMat param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));} - void SetValue(double* doublearray,int M){_error_("PetscMat param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));} - void SetValue(double* pdoublearray,int M,int N){_error_("PetscMat param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));} - void SetValue(Vec vec){_error_("PetscMat param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));} + void SetValue(bool boolean){_error_("PetscMat param of enum %i (%s) cannot hold a boolean",enum_type,EnumToStringx(enum_type));} + void SetValue(int integer){_error_("PetscMat param of enum %i (%s) cannot hold an integer",enum_type,EnumToStringx(enum_type));} + void SetValue(int* intarray,int M){_error_("PetscMat param of enum %i (%s) cannot hold an int array",enum_type,EnumToStringx(enum_type));} + void SetValue(double scalar){_error_("PetscMat param of enum %i (%s) cannot hold a scalar",enum_type,EnumToStringx(enum_type));} + void SetValue(char* string){_error_("PetscMat param of enum %i (%s) cannot hold a string",enum_type,EnumToStringx(enum_type));} + void SetValue(char** stringarray,int M){_error_("PetscMat param of enum %i (%s) cannot hold a string array",enum_type,EnumToStringx(enum_type));} + void SetValue(double* doublearray,int M){_error_("PetscMat param of enum %i (%s) cannot hold a double array",enum_type,EnumToStringx(enum_type));} + void SetValue(double* pdoublearray,int M,int N){_error_("PetscMat param of enum %i (%s) cannot hold a double array",enum_type,EnumToStringx(enum_type));} + void SetValue(Vec vec){_error_("PetscMat param of enum %i (%s) cannot hold a Vec",enum_type,EnumToStringx(enum_type));} void SetValue(Mat mat); - void SetValue(FILE* fid){_error_("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){_error_("PetscMat param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));} + void SetValue(FILE* fid){_error_("PetscMat param of enum %i (%s) cannot hold a FILE",enum_type,EnumToStringx(enum_type));} + void SetValue(double** array, int M, int* mdim_array, int* ndim_array){_error_("PetscMat param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToStringx(enum_type));} char* GetParameterName(void); Index: /issm/trunk/src/c/objects/Params/PetscVecParam.cpp =================================================================== --- /issm/trunk/src/c/objects/Params/PetscVecParam.cpp (revision 8223) +++ /issm/trunk/src/c/objects/Params/PetscVecParam.cpp (revision 8224) @@ -50,5 +50,5 @@ printf("PetscVecParam:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type)); } @@ -59,5 +59,5 @@ int i; printf("PetscVecParam:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type)); VecView(value,PETSC_VIEWER_STDOUT_WORLD); } @@ -193,5 +193,5 @@ /*FUNCTION PetscVecParam::GetParameterName{{{1*/ char* PetscVecParam::GetParameterName(void){ - return EnumToString(this->enum_type); + return EnumToStringx(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/Params/PetscVecParam.h =================================================================== --- /issm/trunk/src/c/objects/Params/PetscVecParam.h (revision 8223) +++ /issm/trunk/src/c/objects/Params/PetscVecParam.h (revision 8224) @@ -50,29 +50,29 @@ /*Param vritual function definitions: {{{1*/ int EnumType(){return enum_type;} - void GetParameterValue(bool* pbool){_error_("PetscVec param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));} - void GetParameterValue(int* pinteger){_error_("PetscVec param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));} - void GetParameterValue(int** pintarray,int* pM){_error_("PetscVec param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));} - void GetParameterValue(double* pdouble){_error_("PetscVec param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));} - void GetParameterValue(char** pstring){_error_("PetscVec param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));} - void GetParameterValue(char*** pstringarray,int* pM){_error_("PetscVec param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM){_error_("PetscVec param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM, int* pN){_error_("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){_error_("PetscVec param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));} - void GetParameterValue(Mat* pmat){_error_("PetscVec param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));} + void GetParameterValue(bool* pbool){_error_("PetscVec param of enum %i (%s) cannot return a bool",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(int* pinteger){_error_("PetscVec param of enum %i (%s) cannot return an integer",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(int** pintarray,int* pM){_error_("PetscVec param of enum %i (%s) cannot return an array of integers",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double* pdouble){_error_("PetscVec param of enum %i (%s) cannot return a double",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(char** pstring){_error_("PetscVec param of enum %i (%s) cannot return a string",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(char*** pstringarray,int* pM){_error_("PetscVec param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM){_error_("PetscVec param of enum %i (%s) cannot return a double array",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM, int* pN){_error_("PetscVec param of enum %i (%s) cannot return a double array",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){_error_("PetscVec param of enum %i (%s) cannot return a matrix array",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(Mat* pmat){_error_("PetscVec param of enum %i (%s) cannot return a Mat",enum_type,EnumToStringx(enum_type));} void GetParameterValue(Vec* poutput); - void GetParameterValue(FILE** pfid){_error_("PetscVec of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));} + void GetParameterValue(FILE** pfid){_error_("PetscVec of enum %i (%s) cannot return a FILE",enum_type,EnumToStringx(enum_type));} - void SetValue(bool boolean){_error_("PetscVec of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));} - void SetValue(int integer){_error_("PetscVec of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));} - void SetValue(int* intarray,int M){_error_("PetscVec of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));} - void SetValue(double scalar){_error_("PetscVec of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));} - void SetValue(char* string){_error_("PetscVec of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));} - void SetValue(char** stringarray,int M){_error_("PetscVec of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));} - void SetValue(double* doublearray,int M){_error_("PetscVec of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));} - void SetValue(double* pdoublearray,int M,int N){_error_("PetscVec of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));} + void SetValue(bool boolean){_error_("PetscVec of enum %i (%s) cannot hold a boolean",enum_type,EnumToStringx(enum_type));} + void SetValue(int integer){_error_("PetscVec of enum %i (%s) cannot hold an integer",enum_type,EnumToStringx(enum_type));} + void SetValue(int* intarray,int M){_error_("PetscVec of enum %i (%s) cannot hold an int array",enum_type,EnumToStringx(enum_type));} + void SetValue(double scalar){_error_("PetscVec of enum %i (%s) cannot hold a scalar",enum_type,EnumToStringx(enum_type));} + void SetValue(char* string){_error_("PetscVec of enum %i (%s) cannot hold a string",enum_type,EnumToStringx(enum_type));} + void SetValue(char** stringarray,int M){_error_("PetscVec of enum %i (%s) cannot hold a string array",enum_type,EnumToStringx(enum_type));} + void SetValue(double* doublearray,int M){_error_("PetscVec of enum %i (%s) cannot hold a double array",enum_type,EnumToStringx(enum_type));} + void SetValue(double* pdoublearray,int M,int N){_error_("PetscVec of enum %i (%s) cannot hold a double array",enum_type,EnumToStringx(enum_type));} void SetValue(Vec vec); - void SetValue(Mat mat){_error_("PetscVec of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));} - void SetValue(FILE* fid){_error_("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){_error_("PetscVec param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));} + void SetValue(Mat mat){_error_("PetscVec of enum %i (%s) cannot hold a Mat",enum_type,EnumToStringx(enum_type));} + void SetValue(FILE* fid){_error_("PetscVec of enum %i (%s) cannot hold a FILE",enum_type,EnumToStringx(enum_type));} + void SetValue(double** array, int M, int* mdim_array, int* ndim_array){_error_("PetscVec param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToStringx(enum_type));} char* GetParameterName(void); Index: /issm/trunk/src/c/objects/Params/StringArrayParam.cpp =================================================================== --- /issm/trunk/src/c/objects/Params/StringArrayParam.cpp (revision 8223) +++ /issm/trunk/src/c/objects/Params/StringArrayParam.cpp (revision 8224) @@ -73,5 +73,5 @@ printf("StringArrayParam:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(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 EnumToString(this->enum_type); + return EnumToStringx(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/Params/StringArrayParam.h =================================================================== --- /issm/trunk/src/c/objects/Params/StringArrayParam.h (revision 8223) +++ /issm/trunk/src/c/objects/Params/StringArrayParam.h (revision 8224) @@ -52,29 +52,29 @@ /*Param vritual function definitions: {{{1*/ int EnumType(){return enum_type;} - void GetParameterValue(bool* pbool){_error_("StringArray param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));} - void GetParameterValue(int* pinteger){_error_("StringArray param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));} - void GetParameterValue(int** pintarray,int* pM){_error_("StringArray param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));} - void GetParameterValue(double* pdouble){_error_("StringArray param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));} - void GetParameterValue(char** pstring){_error_("StringArray param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));} + void GetParameterValue(bool* pbool){_error_("StringArray param of enum %i (%s) cannot return a bool",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(int* pinteger){_error_("StringArray param of enum %i (%s) cannot return an integer",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(int** pintarray,int* pM){_error_("StringArray param of enum %i (%s) cannot return an array of integers",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double* pdouble){_error_("StringArray param of enum %i (%s) cannot return a double",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(char** pstring){_error_("StringArray param of enum %i (%s) cannot return a string",enum_type,EnumToStringx(enum_type));} void GetParameterValue(char*** pstringarray,int* pM); - void GetParameterValue(double** pdoublearray,int* pM){_error_("StringArray param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM, int* pN){_error_("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){_error_("Vec param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));} - void GetParameterValue(Vec* pvec){_error_("StringArray param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));} - void GetParameterValue(Mat* pmat){_error_("StringArray param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));} - void GetParameterValue(FILE** pfid){_error_("StringArray param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM){_error_("StringArray param of enum %i (%s) cannot return a double array",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM, int* pN){_error_("StringArray param of enum %i (%s) cannot return a double array",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){_error_("Vec param of enum %i (%s) cannot return a matrix array",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(Vec* pvec){_error_("StringArray param of enum %i (%s) cannot return a Vec",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(Mat* pmat){_error_("StringArray param of enum %i (%s) cannot return a Mat",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(FILE** pfid){_error_("StringArray param of enum %i (%s) cannot return a FILE",enum_type,EnumToStringx(enum_type));} - void SetValue(bool boolean){_error_("StringArray param of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));} - void SetValue(int integer){_error_("StringArray param of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));} - void SetValue(int* intarray,int M){_error_("StringArray param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));} - void SetValue(double scalar){_error_("StringArray param of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));} - void SetValue(char* string){_error_("StringArray param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));} + void SetValue(bool boolean){_error_("StringArray param of enum %i (%s) cannot hold a boolean",enum_type,EnumToStringx(enum_type));} + void SetValue(int integer){_error_("StringArray param of enum %i (%s) cannot hold an integer",enum_type,EnumToStringx(enum_type));} + void SetValue(int* intarray,int M){_error_("StringArray param of enum %i (%s) cannot hold an int array",enum_type,EnumToStringx(enum_type));} + void SetValue(double scalar){_error_("StringArray param of enum %i (%s) cannot hold a scalar",enum_type,EnumToStringx(enum_type));} + void SetValue(char* string){_error_("StringArray param of enum %i (%s) cannot hold a string",enum_type,EnumToStringx(enum_type));} void SetValue(char** stringarray,int M); - void SetValue(double* doublearray,int M){_error_("StringArray param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));} - void SetValue(double* pdoublearray,int M,int N){_error_("StringArray param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));} - void SetValue(Vec vec){_error_("StringArray param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));} - void SetValue(Mat mat){_error_("StringArray param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));} - void SetValue(FILE* fid){_error_("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){_error_("StringArray param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));} + void SetValue(double* doublearray,int M){_error_("StringArray param of enum %i (%s) cannot hold a double array",enum_type,EnumToStringx(enum_type));} + void SetValue(double* pdoublearray,int M,int N){_error_("StringArray param of enum %i (%s) cannot hold a double array",enum_type,EnumToStringx(enum_type));} + void SetValue(Vec vec){_error_("StringArray param of enum %i (%s) cannot hold a Vec",enum_type,EnumToStringx(enum_type));} + void SetValue(Mat mat){_error_("StringArray param of enum %i (%s) cannot hold a Mat",enum_type,EnumToStringx(enum_type));} + void SetValue(FILE* fid){_error_("StringArray param of enum %i (%s) cannot hold a FILE",enum_type,EnumToStringx(enum_type));} + void SetValue(double** array, int M, int* mdim_array, int* ndim_array){_error_("StringArray param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToStringx(enum_type));} char* GetParameterName(void); Index: /issm/trunk/src/c/objects/Params/StringParam.cpp =================================================================== --- /issm/trunk/src/c/objects/Params/StringParam.cpp (revision 8223) +++ /issm/trunk/src/c/objects/Params/StringParam.cpp (revision 8224) @@ -50,5 +50,5 @@ void StringParam::DeepEcho(void){ printf("StringParam:\n"); - printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type)); + printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type)); printf(" value: %s\n",this->value); } @@ -158,5 +158,5 @@ /*FUNCTION StringParam::GetParameterName{{{1*/ char* StringParam::GetParameterName(void){ - return EnumToString(this->enum_type); + return EnumToStringx(this->enum_type); } /*}}}*/ Index: /issm/trunk/src/c/objects/Params/StringParam.h =================================================================== --- /issm/trunk/src/c/objects/Params/StringParam.h (revision 8223) +++ /issm/trunk/src/c/objects/Params/StringParam.h (revision 8224) @@ -50,29 +50,29 @@ /*Param vritual function definitions: {{{1*/ int EnumType(){return enum_type;} - void GetParameterValue(bool* pbool){_error_("String param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));} - void GetParameterValue(int* pinteger){_error_("String param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));} - void GetParameterValue(int** pintarray,int* pM){_error_("String param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));} - void GetParameterValue(double* pdouble){_error_("String param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));} + void GetParameterValue(bool* pbool){_error_("String param of enum %i (%s) cannot return a bool",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(int* pinteger){_error_("String param of enum %i (%s) cannot return an integer",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(int** pintarray,int* pM){_error_("String param of enum %i (%s) cannot return an array of integers",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double* pdouble){_error_("String param of enum %i (%s) cannot return a double",enum_type,EnumToStringx(enum_type));} void GetParameterValue(char** pstring); - void GetParameterValue(char*** pstringarray,int* pM){_error_("String param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM){_error_("String param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));} - void GetParameterValue(double** pdoublearray,int* pM, int* pN){_error_("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){_error_("String param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));} - void GetParameterValue(Vec* pvec){_error_("String param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));} - void GetParameterValue(Mat* pmat){_error_("String param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));} - void GetParameterValue(FILE** pfid){_error_("Bool param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));} + void GetParameterValue(char*** pstringarray,int* pM){_error_("String param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM){_error_("String param of enum %i (%s) cannot return a double array",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double** pdoublearray,int* pM, int* pN){_error_("String param of enum %i (%s) cannot return a double array",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){_error_("String param of enum %i (%s) cannot return a matrix array",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(Vec* pvec){_error_("String param of enum %i (%s) cannot return a Vec",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(Mat* pmat){_error_("String param of enum %i (%s) cannot return a Mat",enum_type,EnumToStringx(enum_type));} + void GetParameterValue(FILE** pfid){_error_("Bool param of enum %i (%s) cannot return a FILE",enum_type,EnumToStringx(enum_type));} - void SetValue(bool boolean){_error_("String param of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));} - void SetValue(int integer){_error_("String param of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));} - void SetValue(int* intarray,int M){_error_("String param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));} - void SetValue(double scalar){_error_("String param of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));} + void SetValue(bool boolean){_error_("String param of enum %i (%s) cannot hold a boolean",enum_type,EnumToStringx(enum_type));} + void SetValue(int integer){_error_("String param of enum %i (%s) cannot hold an integer",enum_type,EnumToStringx(enum_type));} + void SetValue(int* intarray,int M){_error_("String param of enum %i (%s) cannot hold an int array",enum_type,EnumToStringx(enum_type));} + void SetValue(double scalar){_error_("String param of enum %i (%s) cannot hold a scalar",enum_type,EnumToStringx(enum_type));} void SetValue(char* string); - void SetValue(char** stringarray,int M){_error_("String param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));} - void SetValue(double* doublearray,int M){_error_("String param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));} - void SetValue(double* pdoublearray,int M,int N){_error_("String param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));} - void SetValue(Vec vec){_error_("String param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));} - void SetValue(Mat mat){_error_("String param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));} - void SetValue(FILE* fid){_error_("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){_error_("String param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));} + void SetValue(char** stringarray,int M){_error_("String param of enum %i (%s) cannot hold a string array",enum_type,EnumToStringx(enum_type));} + void SetValue(double* doublearray,int M){_error_("String param of enum %i (%s) cannot hold a double array",enum_type,EnumToStringx(enum_type));} + void SetValue(double* pdoublearray,int M,int N){_error_("String param of enum %i (%s) cannot hold a double array",enum_type,EnumToStringx(enum_type));} + void SetValue(Vec vec){_error_("String param of enum %i (%s) cannot hold a Vec",enum_type,EnumToStringx(enum_type));} + void SetValue(Mat mat){_error_("String param of enum %i (%s) cannot hold a Mat",enum_type,EnumToStringx(enum_type));} + void SetValue(FILE* fid){_error_("String param of enum %i (%s) cannot hold a FILE",enum_type,EnumToStringx(enum_type));} + void SetValue(double** array, int M, int* mdim_array, int* ndim_array){_error_("String param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToStringx(enum_type));} char* GetParameterName(void); Index: /issm/trunk/src/c/shared/Numerics/IsInputConverged.cpp =================================================================== --- /issm/trunk/src/c/shared/Numerics/IsInputConverged.cpp (revision 8223) +++ /issm/trunk/src/c/shared/Numerics/IsInputConverged.cpp (revision 8224) @@ -53,5 +53,5 @@ else eps=0; } - else _error_("%s%s%s"," convergence criterion ",EnumToString(criterion_enum)," not supported yet!"); + else _error_("%s%s%s"," convergence criterion ",EnumToStringx(criterion_enum)," not supported yet!"); /*Assign output pointers:*/ Index: /issm/trunk/src/c/shared/Numerics/PetscOptionsFromAnalysis.cpp =================================================================== --- /issm/trunk/src/c/shared/Numerics/PetscOptionsFromAnalysis.cpp (revision 8223) +++ /issm/trunk/src/c/shared/Numerics/PetscOptionsFromAnalysis.cpp (revision 8224) @@ -57,5 +57,5 @@ if (found==-1){ /*ok, we did not find anything, this is not good! error out: */ - _error_("%s%s","could find neither a default analysis nor analysis ",EnumToString(analysis_type)); + _error_("%s%s","could find neither a default analysis nor analysis ",EnumToStringx(analysis_type)); } Index: /issm/trunk/src/c/shared/Numerics/extrema.cpp =================================================================== --- /issm/trunk/src/c/shared/Numerics/extrema.cpp (revision 8223) +++ /issm/trunk/src/c/shared/Numerics/extrema.cpp (revision 8224) @@ -11,9 +11,17 @@ double min(double a,double b){ - if (a<=b)return a; + if (a=b)return a; + if (a>b)return a; else return b; } +int max(int a,int b){ + if (a>b)return a; + else return b; +} Index: /issm/trunk/src/c/shared/Numerics/numerics.h =================================================================== --- /issm/trunk/src/c/shared/Numerics/numerics.h (revision 8223) +++ /issm/trunk/src/c/shared/Numerics/numerics.h (revision 8224) @@ -18,4 +18,6 @@ double min(double a,double b); double max(double a,double b); +int min(int a,int b); +int max(int a,int b); double OptFunc(double scalar, OptArgs* optargs); void BrentSearch(double* psearch_scalar,double* pJ,OptPars* optpars,double (*f)(double,OptArgs*), OptArgs* optargs); Index: /issm/trunk/src/c/solutions/AdjointCorePointerFromSolutionEnum.cpp =================================================================== --- /issm/trunk/src/c/solutions/AdjointCorePointerFromSolutionEnum.cpp (revision 8223) +++ /issm/trunk/src/c/solutions/AdjointCorePointerFromSolutionEnum.cpp (revision 8224) @@ -35,5 +35,5 @@ break; default: - _error_("No adjoint has been implemented for solution %s yet",EnumToString(solutiontype)); + _error_("No adjoint has been implemented for solution %s yet",EnumToStringx(solutiontype)); break; } Index: /issm/trunk/src/c/solutions/CorePointerFromSolutionEnum.cpp =================================================================== --- /issm/trunk/src/c/solutions/CorePointerFromSolutionEnum.cpp (revision 8223) +++ /issm/trunk/src/c/solutions/CorePointerFromSolutionEnum.cpp (revision 8224) @@ -62,5 +62,5 @@ break; default: - _error_("%s%s%s"," solution type: ",EnumToString(solutiontype)," not supported yet!"); + _error_("%s%s%s"," solution type: ",EnumToStringx(solutiontype)," not supported yet!"); break; } Index: /issm/trunk/src/c/solutions/SolutionConfiguration.cpp =================================================================== --- /issm/trunk/src/c/solutions/SolutionConfiguration.cpp (revision 8223) +++ /issm/trunk/src/c/solutions/SolutionConfiguration.cpp (revision 8224) @@ -131,5 +131,5 @@ default: - _error_("%s%s%s"," solution type: ",EnumToString(solutiontype)," not supported yet!"); + _error_("%s%s%s"," solution type: ",EnumToStringx(solutiontype)," not supported yet!"); break; } Index: /issm/trunk/src/c/solutions/control_core.cpp =================================================================== --- /issm/trunk/src/c/solutions/control_core.cpp (revision 8223) +++ /issm/trunk/src/c/solutions/control_core.cpp (revision 8224) @@ -122,5 +122,5 @@ for(i=0;ielements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,control_type[i]); femmodel->results->AddObject(new DoubleVecExternalResult(femmodel->results->Size()+1,JEnum,J,nsteps,1,0)); - //femmodel->results->AddObject(new StringExternalResult(femmodel->results->Size()+1,ControlTypeEnum,EnumToString(control_type),1,0)); + //femmodel->results->AddObject(new StringExternalResult(femmodel->results->Size()+1,ControlTypeEnum,EnumToStringx(control_type),1,0)); } Index: /issm/trunk/src/c/solutions/controlrestart.cpp =================================================================== --- /issm/trunk/src/c/solutions/controlrestart.cpp (revision 8223) +++ /issm/trunk/src/c/solutions/controlrestart.cpp (revision 8224) @@ -26,5 +26,5 @@ for(int i=0;ielements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,control_type[i]); femmodel->results->AddObject(new DoubleVecExternalResult(femmodel->results->Size()+1,JEnum,J,nsteps,1,0)); - //femmodel->results->AddObject(new StringExternalResult(femmodel->results->Size()+1,ControlTypeEnum,EnumToString(control_type),1,0)); + //femmodel->results->AddObject(new StringExternalResult(femmodel->results->Size()+1,ControlTypeEnum,EnumToStringx(control_type),1,0)); /*write to disk: */ Index: /issm/trunk/src/c/solutions/gradient_core.cpp =================================================================== --- /issm/trunk/src/c/solutions/gradient_core.cpp (revision 8223) +++ /issm/trunk/src/c/solutions/gradient_core.cpp (revision 8224) @@ -36,5 +36,5 @@ for (int i=0;ielements,femmodel->nodes, femmodel->vertices,femmodel->loads, femmodel->materials,femmodel->parameters, control_type[i]); @@ -53,6 +53,6 @@ /*Get scaling factor of current control:*/ VecNorm(new_gradient,NORM_INFINITY,&norm_grad); - if(norm_grad<=0) _error_("||∂J/∂α||∞ = 0 gradient norm of J with respect to %s is zero",EnumToString(control_type[i])); - if(isnan(norm_grad))_error_("||∂J/∂α||∞ = NaN gradient norm of J with respect to %s is NaN" ,EnumToString(control_type[i])); + if(norm_grad<=0) _error_("||∂J/∂α||∞ = 0 gradient norm of J with respect to %s is zero",EnumToStringx(control_type[i])); + if(isnan(norm_grad))_error_("||∂J/∂α||∞ = NaN gradient norm of J with respect to %s is NaN" ,EnumToStringx(control_type[i])); if(i==0 || (optscal_list[num_controls*step+i]/norm_grad)