Changeset 8224


Ignore:
Timestamp:
05/10/11 09:30:01 (14 years ago)
Author:
Mathieu Morlighem
Message:

moved EnumToString to EnumToStringx which is now a module

Location:
issm/trunk/src/c
Files:
6 added
94 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk/src/c/Container/DataSet.cpp

    r8129 r8224  
    123123         * because this is a nasty error: */
    124124        if (marshalled_dataset!=old_marshalled_dataset){
    125                 _error_("final marshalled dataset \"%s\" is different from initial one!",EnumToString(enum_type));
     125                _error_("final marshalled dataset \"%s\" is different from initial one!",EnumToStringx(enum_type));
    126126                abort();
    127127        }
    … …  
    355355                                break;
    356356                        default:
    357                                 _error_("could not recognize enum type: %i (%s)",enum_type,EnumToString(enum_type));
     357                                _error_("could not recognize enum type: %i (%s)",enum_type,EnumToStringx(enum_type));
    358358                }
    359359
    … …  
    479479        /*Carry out a binary search on the sorted_ids: */
    480480        if(!binary_search(&id_offset,eid, sorted_ids,objects.size())){
    481                 _error_("could not find object with id %i in DataSet %s",eid,EnumToString(enum_type));
     481                _error_("could not find object with id %i in DataSet %s",eid,EnumToStringx(enum_type));
    482482        }
    483483

  • issm/trunk/src/c/Container/Inputs.cpp

    r6412 r8224  
    6363                /*we could not find an input with the correct enum type. No defaults values were provided,
    6464                 * error out: */
    65                 _error_("could not find input with enum type %i (%s)",enum_type,EnumToString(enum_type));
     65                _error_("could not find input with enum type %i (%s)",enum_type,EnumToStringx(enum_type));
    6666        }
    6767
    … …  
    9191                /*we could not find an input with the correct enum type. No defaults values were provided,
    9292                 * error out: */
    93                 _error_("could not find input with enum type %i (%s)",enum_type,EnumToString(enum_type));
     93                _error_("could not find input with enum type %i (%s)",enum_type,EnumToStringx(enum_type));
    9494        }
    9595
    … …  
    119119                /*we could not find an input with the correct enum type. No defaults values were provided,
    120120                 * error out: */
    121                 _error_("could not find input with enum type %i (%s)",enum_type,EnumToString(enum_type));
     121                _error_("could not find input with enum type %i (%s)",enum_type,EnumToStringx(enum_type));
    122122        }
    123123
    … …  
    147147                /*we could not find an input with the correct enum type. No defaults values were provided,
    148148                 * error out: */
    149                 _error_("could not find input with enum type %i (%s)",enum_type,EnumToString(enum_type));
     149                _error_("could not find input with enum type %i (%s)",enum_type,EnumToStringx(enum_type));
    150150        }
    151151
    … …  
    219219
    220220        /*some checks: */
    221         if(!constrain_input) _error_(" input %s could not be found!",EnumToString(constrain_enum));
     221        if(!constrain_input) _error_(" input %s could not be found!",EnumToStringx(constrain_enum));
    222222
    223223        /*Apply ContrainMin: */
    … …  
    260260        }
    261261        else{
    262                 _error_("Input %s not found",EnumToString(enumtype));
     262                _error_("Input %s not found",EnumToStringx(enumtype));
    263263        }
    264264
    … …  
    281281        }
    282282        else{
    283                 _error_("Input %s not found",EnumToString(enumtype));
     283                _error_("Input %s not found",EnumToStringx(enumtype));
    284284        }
    285285
    … …  
    302302        }
    303303        else{
    304                 _error_("Input %s not found",EnumToString(enumtype));
     304                _error_("Input %s not found",EnumToStringx(enumtype));
    305305        }
    306306
    … …  
    323323        }
    324324        else{
    325                 _error_("Input %s not found",EnumToString(enumtype));
     325                _error_("Input %s not found",EnumToStringx(enumtype));
    326326        }
    327327
    … …  
    375375        /*Make a copy of the original input: */
    376376        original=(Input*)this->GetInput(original_enum);
    377         if(!original)_error_("could not find input with enum: %s",EnumToString(original_enum));
     377        if(!original)_error_("could not find input with enum: %s",EnumToStringx(original_enum));
    378378        copy=(Input*)original->copy();
    379379
    … …  
    422422
    423423        /*some checks: */
    424         if(!xinput) _error_(" input %s could not be found!",EnumToString(XEnum));
    425         if(!yinput) _error_(" input %s could not be found!",EnumToString(YEnum));
     424        if(!xinput) _error_(" input %s could not be found!",EnumToStringx(XEnum));
     425        if(!yinput) _error_(" input %s could not be found!",EnumToStringx(YEnum));
    426426
    427427        /*Apply AXPY: */

  • issm/trunk/src/c/Container/Nodes.cpp

    r6412 r8224  
    7474
    7575        /*some check: */
    76         if ((setenum!=GsetEnum) && (setenum!=FsetEnum) && (setenum!=SsetEnum))_error_("%s%s%s"," dof distribution for set of enum type ",EnumToString(setenum)," not supported yet!");
     76        if ((setenum!=GsetEnum) && (setenum!=FsetEnum) && (setenum!=SsetEnum))_error_("%s%s%s"," dof distribution for set of enum type ",EnumToStringx(setenum)," not supported yet!");
    7777
    7878        /*Go through objects, and distribute dofs locally, from 0 to numberofdofs: */

  • issm/trunk/src/c/Container/Options.cpp

    r7760 r8224  
    266266                                /*Else: not supported*/
    267267                                else{
    268                                         _error_("Cannot recover field \"%s\" for an option of type %s",name,EnumToString(option->Enum()));
     268                                        _error_("Cannot recover field \"%s\" for an option of type %s",name,EnumToStringx(option->Enum()));
    269269                                }
    270270                        }

  • issm/trunk/src/c/Container/Results.cpp

    r6389 r8224  
    129129        for(i=0;i<maxfields;i++){
    130130                if (enums[i]>0){
    131                         fnames[count]=EnumToString(enums[i]);
     131                        fnames[count]=EnumToStringx(enums[i]);
    132132                        count++;
    133133                }

  • issm/trunk/src/c/EnumDefinitions/EnumDefinitions.h

    r8117 r8224  
    66#ifndef _ENUM_DEFINITIONS_
    77#define _ENUM_DEFINITIONS_
     8
     9#include "../modules/EnumToStringx/EnumToStringx.h"
     10#include "../modules/StringToEnumx/StringToEnumx.h"
    811
    912enum definitions{
    … …  
    444447
    445448/*Functions on enums: */
    446 char *EnumToString(int enum_type);
    447 int   StringToEnum(char *string);
    448449char *EnumToModelField(int  en);
    449450

  • issm/trunk/src/c/EnumDefinitions/EnumToModelField.cpp

    r7076 r8224  
    2323                case VyObsEnum : return "vy_obs";
    2424                case GroundingLineMigrationEnum : return "gl_migration";
    25                 default : _error_("No model field is associated to enum %s",EnumToString(en));
     25                default : _error_("No model field is associated to enum %s",EnumToStringx(en));
    2626        }
    2727}

  • issm/trunk/src/c/EnumDefinitions/README

    r5227 r8224  
    11
    22DO NOT MODIFY the following files:
    3 - StringToEnum.cpp
    4 - EnumToString.cpp
     3- StringToEnumx.cpp
     4- EnumToStringx.cpp
    55- src/m/enum/*
    66all these files are automatically synchronized with EnumDefinitions.h and EnumToModelField.cpp

  • issm/trunk/src/c/EnumDefinitions/Synchronize.sh

    r6412 r8224  
    11#!/bin/bash
    2 #Synchronize EnumToString.cpp and StringToEnum.cpp
     2#Synchronize EnumToStringx.cpp and StringToEnumx.cpp and matlab Enums
    33
     4#Get all lines of EnumDefinitions2.h which hold Enum | remove all comas | add line number in the first column > put everything in file temp
     5cat 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
    46
    5 #first remove existing files
    6 rm EnumToString.cpp StringToEnum.cpp
     7#Removed existing files
    78rm $ISSM_TIER/src/m/enum/*.m
    8 
    9 echo "Synchronizing Enums..."
     9rm $ISSM_TIER/src/c/modules/EnumToStringx/EnumToStringx.cpp
     10rm $ISSM_TIER/src/c/modules/StringToEnumx/StringToEnumx.cpp
    1011
    1112#Take care of EnumToModelField.m first (easy)
    1213#Build EnumToModelField.m {{{1
    13 cat <<END > EnumToModelField.m
     14cat <<END > $ISSM_TIER/src/m/enum/EnumToModelField.m
    1415function string=EnumToModelField(enum)
    1516%ENUMTOMODELFIELD - output string of model field associated to enum
    … …  
    3536#}}}
    3637
    37 #Get all lines of EnumDefinitions2.h which hold Enum | remove all comas | add line number in the first column > put everything in file temp
    38 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
    39 #Build header of EnumToString.cpp {{{1
    40 cat <<END > EnumToString.cpp
     38#Build header of EnumToStringx.cpp {{{1
     39cat <<END >  $ISSM_TIER/src/c/modules/EnumToStringx/EnumToStringx.cpp
    4140/*
    42 * \file EnumToString.cpp:
     41* \file EnumToStringx.cpp:
    4342* \brief: output string associated with enum
    4443*
    … …  
    4847*/
    4948
    50 #include "../shared/shared.h"
    51 #include "../include/include.h"
    52 #include "./EnumDefinitions.h"
     49#include "../../shared/shared.h"
     50#include "../../include/include.h"
     51#include "./EnumToStringx.h"
    5352
    54 char* EnumToString(int en){
     53char* EnumToStringx(int en){
    5554
    5655        switch(en){
    … …  
    5857END
    5958#}}}
    60 #Build header of StringToEnum.cpp {{{1
    61 cat <<END > StringToEnum.cpp
     59#Build header of StringToEnumx.cpp {{{1
     60cat <<END > $ISSM_TIER/src/c/modules/StringToEnumx/StringToEnumx.cpp
    6261/*
    63 * \file StringToEnum.cpp:
     62* \file StringToEnumx.cpp:
    6463* \brief: output enum associated with string
    6564*
    … …  
    6968*/
    7069
    71 #include "../shared/shared.h"
    72 #include "../include/include.h"
    73 #include "./EnumDefinitions.h"
     70#include "../../shared/shared.h"
     71#include "../../include/include.h"
     72#include "./StringToEnumx.h"
    7473
    75 int  StringToEnum(char* name){
    76 
    77 END
    78 #}}}
    79 #Build header of EnumToString.m {{{1
    80 cat <<END > EnumToString.m
    81 function string=EnumToString(enum)
    82 %ENUMASSTRING - output string associated with enum
    83 %
    84 %   WARNING: DO NOT MODIFY THIS FILE
    85 %            this file has been automatically generated by src/c/EnumDefinitions/Synchronize.sh
    86 %            Please read src/c/EnumDefinitions/README for more information
    87 %
    88 %   Usage:
    89 %      string=EnumToString(enum)
    90 
    91 switch enum,
    92 
    93 END
    94 #}}}
    95 #Build header of StringToEnum.m {{{1
    96 cat <<END > StringToEnum.m
    97 function enum=StringToEnum(name)
    98 %STRINGASENUM - output enum associated with string
    99 %
    100 %   WARNING: DO NOT MODIFY THIS FILE
    101 %            this file has been automatically generated by src/c/EnumDefinitions/Synchronize.sh
    102 %            Please read src/c/EnumDefinitions/README for more information
    103 %
    104 %   Usage:
    105 %      enum=StringToEnum(name)
     74int  StringToEnumx(char* name){
    10675
    10776END
    … …  
    150119%      macro=$NAMEENUM()
    151120
    152 macro=$ENUM;
     121macro=StringToEnum('$NAME');
    153122END
    154123#}}}
    155 
    156         #Add case to EnumToString.cpp {{{
    157         cat <<END >> EnumToString.cpp
     124        #Add case to EnumToStringx.cpp {{{
     125        cat <<END >> $ISSM_TIER/src/c/modules/EnumToStringx/EnumToStringx.cpp
    158126                case $NAMEENUM : return "$NAME";
    159127END
    160128#}}}
    161         #Add case to StringToEnum.cpp {{{
     129        #Add case to StringToEnumx.cpp {{{
    162130        if [ $i -eq 1 ]
    163131        then
    164                 cat <<END >> StringToEnum.cpp
     132                cat <<END >> $ISSM_TIER/src/c/modules/StringToEnumx/StringToEnumx.cpp
    165133        if (strcmp(name,"$NAME")==0) return $NAMEENUM;
    166134END
    167135        else
    168                 cat <<END >> StringToEnum.cpp
     136                cat <<END >> $ISSM_TIER/src/c/modules/StringToEnumx/StringToEnumx.cpp
    169137        else if (strcmp(name,"$NAME")==0) return $NAMEENUM;
    170138END
    … …  
    172140#}}}
    173141
    174 #Add case to EnumToString.m {{{
    175 cat <<END >> EnumToString.m
    176 case $NAMEENUM(), string='$NAME'; return
    177 END
    178 #}}}
    179         #Add case to StringToEnum.m {{{
    180         if [ $i -eq 1 ]
    181         then
    182                 cat <<END >> StringToEnum.m
    183                 if (strcmpi(name,'$NAME')), enum=$NAMEENUM(); return
    184 END
    185                 else
    186                         cat <<END >> StringToEnum.m
    187                         elseif (strcmpi(name,'$NAME')), enum=$NAMEENUM(); return
    188 END
    189                 fi
    190                 #}}}
    191 
    192142done
    193143
    194 #Add footer of of EnumToString.cpp{{{1
    195 cat <<END >> EnumToString.cpp
     144#Add footer of of EnumToStringx.cpp{{{1
     145cat <<END >> $ISSM_TIER/src/c/modules/EnumToStringx/EnumToStringx.cpp
    196146                default : return "unknown";
    197147
    … …  
    200150END
    201151#}}}
    202 #Add footer of of StringToEnum.cpp{{{1
    203 cat <<END >> StringToEnum.cpp
     152#Add footer of of StringToEnumx.cpp{{{1
     153cat <<END >> $ISSM_TIER/src/c/modules/StringToEnumx/StringToEnumx.cpp
    204154        else _error_("Enum %s not found",name);
    205155
    … …  
    207157END
    208158#}}}
    209 #Add footer of of EnumToString.m{{{1
    210 cat <<END >> EnumToString.m
    211 otherwise, error(['Enum ' num2str(enum)  ' not found']);
    212159
    213 end
    214 END
    215 #}}}
    216 #Add footer of of StringToEnum.m{{{1
    217 cat <<END >> StringToEnum.m
    218 else error(['Enum ' name  ' not found']);
    219 
    220         end
    221 END
    222 #}}}
    223 
    224 #move files to new location {{{1
    225 mv StringToEnum.m         $ISSM_TIER/src/m/enum/
    226 mv EnumToString.m         $ISSM_TIER/src/m/enum/
    227 mv EnumToModelField.m     $ISSM_TIER/src/m/enum/
    228 #}}}
    229160#clean up{{{
    230161rm temp

  • issm/trunk/src/c/Makefile.am

    r8206 r8224  
    398398                                        ./io/pfclose.cpp\
    399399                                        ./EnumDefinitions/EnumDefinitions.h\
    400                                         ./EnumDefinitions/EnumToString.cpp\
    401                                         ./EnumDefinitions/StringToEnum.cpp\
    402400                                        ./EnumDefinitions/EnumToModelField.cpp\
    403401                                        ./modules/AddExternalResultx/AddExternalResultx.h\
    … …  
    612610                                        ./modules/ElementConnectivityx/ElementConnectivityx.cpp\
    613611                                        ./modules/ElementConnectivityx/ElementConnectivityx.h\
     612                                        ./modules/EnumToStringx/EnumToStringx.cpp\
     613                                        ./modules/EnumToStringx/EnumToStringx.h\
     614                                        ./modules/StringToEnumx/StringToEnumx.cpp\
     615                                        ./modules/StringToEnumx/StringToEnumx.h\
    614616                                        ./modules/MassFluxx/MassFluxx.cpp\
    615617                                        ./modules/MassFluxx/MassFluxx.h\
    … …  
    10351037                                        ./io/ParsePetscOptions.cpp\
    10361038                                        ./EnumDefinitions/EnumDefinitions.h\
    1037                                         ./EnumDefinitions/EnumToString.cpp\
    1038                                         ./EnumDefinitions/StringToEnum.cpp\
    10391039                                        ./EnumDefinitions/EnumToModelField.cpp\
    10401040                                        ./modules/AddExternalResultx/AddExternalResultx.h\
    … …  
    12401240                                        ./modules/Reduceloadx/Reduceloadx.h\
    12411241                                        ./modules/Reduceloadx/Reduceloadx.cpp\
     1242                                        ./modules/EnumToStringx/EnumToStringx.cpp\
     1243                                        ./modules/EnumToStringx/EnumToStringx.h\
     1244                                        ./modules/StringToEnumx/StringToEnumx.cpp\
     1245                                        ./modules/StringToEnumx/StringToEnumx.h\
    12421246                                        ./modules/MassFluxx/MassFluxx.cpp\
    12431247                                        ./modules/MassFluxx/MassFluxx.h\

  • issm/trunk/src/c/io/FetchParams.cpp

    r7740 r8224  
    5353                /*Get i'th field: */
    5454                name=(char*)mxGetFieldNameByNumber(dataref,count);
    55                 enum_type=StringToEnum(name);
     55                enum_type=StringToEnumx(name);
    5656                pfield=mxGetFieldByNumber(dataref,0,count);
    5757                _assert_(pfield);

  • issm/trunk/src/c/io/ParsePetscOptions.cpp

    r6028 r8224  
    6363               
    6464                        if (line[0]=='+'){ /*this is the analysis line: */
    65                                 analyses[numanalyses]=StringToEnum(&line[1]);  //skip the '+'
     65                                analyses[numanalyses]=StringToEnumx(&line[1]);  //skip the '+'
    6666                                numanalyses++;
    6767                        }

  • issm/trunk/src/c/modules/CostFunctionx/CostFunctionx.cpp

    r5476 r8224  
    2525       
    2626        /*Get response*/
    27         Responsex(&J,elements,nodes,vertices,loads,materials,parameters,EnumToString(response),false); //False means DO NOT process units
     27        Responsex(&J,elements,nodes,vertices,loads,materials,parameters,EnumToStringx(response),false); //False means DO NOT process units
    2828
    2929        /*Add Regularization terms: */

  • issm/trunk/src/c/modules/DakotaResponsesx/DakotaResponsesx.cpp

    r6412 r8224  
    5151
    5252                        /*this response was scaled. pick up the response from the inputs: */
    53                         GetVectorFromInputsx(&vertex_response,elements,nodes, vertices, loads, materials, parameters, StringToEnum(root),VertexEnum);
     53                        GetVectorFromInputsx(&vertex_response,elements,nodes, vertices, loads, materials, parameters, StringToEnumx(root),VertexEnum);
    5454
    5555                        /*Now, average it onto the partition grids: */

  • issm/trunk/src/c/modules/GetSolutionFromInputsx/GetSolutionFromInputsx.cpp

    r6412 r8224  
    2626        /*Get size of vector: */
    2727        gsize=nodes->NumberOfDofs(configuration_type,GsetEnum);
    28         if (gsize==0) _error_("Allocating a Vec of size 0 as gsize=0 for configuration: %s",EnumToString(configuration_type));
     28        if (gsize==0) _error_("Allocating a Vec of size 0 as gsize=0 for configuration: %s",EnumToStringx(configuration_type));
    2929       
    3030        /*Initialize solution: */

  • issm/trunk/src/c/modules/GetVectorFromInputsx/GetVectorFromInputsx.cpp

    r7177 r8224  
    2323                }
    2424        }
    25         else _error_("%s%s%s"," vector type: ",EnumToString(type)," not supported yet!");
     25        else _error_("%s%s%s"," vector type: ",EnumToStringx(type)," not supported yet!");
    2626
    2727        VecAssemblyBegin(vector);

  • issm/trunk/src/c/modules/GroundingLineMigrationx/GroundingLineMigrationx.cpp

    r7737 r8224  
    2626        else if(migration_style==SoftMigrationEnum) SoftMigration(elements,nodes, vertices,loads,materials, parameters);
    2727        else if(migration_style==NoneEnum) _printf_(true,"%s\n","NoneEnum supplied for migration style, doing nothing!");
    28         else _error_("%s not supported yet!",EnumToString(migration_style));
     28        else _error_("%s not supported yet!",EnumToStringx(migration_style));
    2929
    3030}

  • issm/trunk/src/c/modules/InputUpdateFromDakotax/InputUpdateFromDakotax.cpp

    r6412 r8224  
    5050
    5151                        /*Now, pick up the parameter corresponding to root: */
    52                         if(!parameters->FindParam(&parameter,NULL,StringToEnum(root))){
     52                        if(!parameters->FindParam(&parameter,NULL,StringToEnumx(root))){
    5353                                _error_("%s%s"," could not find Qmu parameter: ",root);
    5454                        }
    … …  
    6666                                        PetscSynchronizedFlush(MPI_COMM_WORLD);
    6767                                }
    68                                 PetscSynchronizedPrintf(MPI_COMM_WORLD," descriptor: %s root %s enum: %i\n",descriptor,root,StringToEnum(root));
     68                                PetscSynchronizedPrintf(MPI_COMM_WORLD," descriptor: %s root %s enum: %i\n",descriptor,root,StringToEnumx(root));
    6969                                PetscSynchronizedFlush(MPI_COMM_WORLD);
    7070                        #endif
    … …  
    7272
    7373                        /*Update inputs using the parameter vector: */
    74                         InputUpdateFromVectorDakotax( elements,nodes, vertices,loads, materials,  parameters, parameter, StringToEnum(root), VertexEnum);
     74                        InputUpdateFromVectorDakotax( elements,nodes, vertices,loads, materials,  parameters, parameter, StringToEnumx(root), VertexEnum);
    7575
    7676                        /*increment i to skip the distributed values just collected: */
    … …  
    8989                else{
    9090                        /*Ok, standard variable, just update inputs using the variable: */
    91                         InputUpdateFromConstantx( elements,nodes, vertices,loads, materials,  parameters, variables[i],StringToEnum(descriptor));
     91                        InputUpdateFromConstantx( elements,nodes, vertices,loads, materials,  parameters, variables[i],StringToEnumx(descriptor));
    9292                }
    9393        }

  • issm/trunk/src/c/modules/InterpFromGridToMeshx/InterpFromGridToMeshx.cpp

    r8125 r8224  
    170170                                        break;
    171171                                default:
    172                                         printf("Interpolation %s not supported yet\n",EnumToString(interpenum));
     172                                        printf("Interpolation %s not supported yet\n",EnumToStringx(interpenum));
    173173                                        return NULL; /*WARNING: no error because it would blow up the multithreading!*/
    174174                        }

  • issm/trunk/src/c/modules/ModelProcessorx/Control/UpdateElementsAndMaterialsControl.cpp

    r8129 r8224  
    5151                                break;
    5252                        default:
    53                                 _error_("Control %s not implemented yet",EnumToString((int)iomodel->control_type[i]));
     53                                _error_("Control %s not implemented yet",EnumToStringx((int)iomodel->control_type[i]));
    5454                }
    5555        }

  • issm/trunk/src/c/modules/ModelProcessorx/CreateDataSets.cpp

    r7640 r8224  
    108108                        break;
    109109                default:
    110                         _error_("%s%s%s"," analysis_type: ",EnumToString(analysis_type)," not supported yet!");
     110                        _error_("%s%s%s"," analysis_type: ",EnumToStringx(analysis_type)," not supported yet!");
    111111        }
    112112

  • issm/trunk/src/c/modules/ModelProcessorx/DistributeNumDofs.cpp

    r7640 r8224  
    6161                        doftype[5]=StokesApproximationEnum;
    6262                }
    63                 else _error_("Approximationtype %i (%s) not implemented yet for DiagnosticHoriz",(int)*vertices_type,EnumToString((int)*vertices_type));
     63                else _error_("Approximationtype %i (%s) not implemented yet for DiagnosticHoriz",(int)*vertices_type,EnumToStringx((int)*vertices_type));
    6464        }
    6565        else if (analysis_type==DiagnosticVertAnalysisEnum){
    … …  
    9090                numdofs=1;
    9191        }
    92         else _error_("analysis type: %i (%s) not implemented yet",analysis_type,EnumToString(analysis_type));
     92        else _error_("analysis type: %i (%s) not implemented yet",analysis_type,EnumToStringx(analysis_type));
    9393
    9494        /*Now initialize the index*/

  • issm/trunk/src/c/modules/ModelProcessorx/ModelProcessorx.cpp

    r6412 r8224  
    4040                analysis_type=analysis_type_list[i];
    4141       
    42                 _printf_(VerboseMProcessor(),"   create datasets for analysis %s\n",EnumToString(analysis_type));
     42                _printf_(VerboseMProcessor(),"   create datasets for analysis %s\n",EnumToStringx(analysis_type));
    4343                CreateDataSets(&elements,&nodes,&vertices,&materials,&constraints,&loads,&parameters,iomodel,IOMODEL,solution_type,analysis_type,nummodels,i);
    4444        }

  • issm/trunk/src/c/modules/ModelProcessorx/Qmu/CreateParametersQmu.cpp

    r7124 r8224  
    7474                parameters->AddObject(new   StringParam(QmuErrNameEnum,qmuerrname));
    7575                /*}}}*/
    76 
    7776                /*Deal with variable descriptors: {{{1*/
    7877                variabledescriptors=(char**)xmalloc(iomodel->numvariabledescriptors*sizeof(char*));
    … …  
    101100
    102101                /*}}}*/
    103 
    104102                /*Deal with response descriptors: {{{1*/
    105103                responsedescriptors=(char**)xmalloc(iomodel->numresponsedescriptors*sizeof(char*));
    … …  
    125123                parameters->AddObject(new    IntParam(QmuNumberOfResponsesEnum,iomodel->numberofresponses));
    126124                /*}}}*/
    127 
    128125                /*Deal with partitioning: {{{1*/
    129126                /*partition vertices in iomodel->qmu_npart parts, unless a partition is already present: */
    … …  
    142139                parameters->AddObject(new DoubleVecParam(QmuPartEnum,dpart,iomodel->numberofvertices));
    143140                /*}}}*/
    144 
    145141                /*Deal with data needed because of qmu variables: {{{1*/
    146142               
    … …  
    152148                               
    153149                                /*Recover data: */
    154                                 IoModelFetchData(&dakota_parameter,NULL,NULL,iomodel_handle,EnumToModelField(StringToEnum(tag)));
     150                                IoModelFetchData(&dakota_parameter,NULL,NULL,iomodel_handle,EnumToModelField(StringToEnumx(tag)));
    155151
    156152                                /*Convert units: */
    157                                 UnitConversion(dakota_parameter,iomodel->numberofvertices,ExtToIuEnum,StringToEnum(tag),parameters);
     153                                UnitConversion(dakota_parameter,iomodel->numberofvertices,ExtToIuEnum,StringToEnumx(tag),parameters);
    158154
    159155                                /*Add to parameters: */
    160                                 parameters->AddObject(new DoubleVecParam(StringToEnum(tag),dakota_parameter,iomodel->numberofvertices));
     156                                parameters->AddObject(new DoubleVecParam(StringToEnumx(tag),dakota_parameter,iomodel->numberofvertices));
    161157                               
    162158                                /*Free ressources:*/
    … …  
    165161                }
    166162                /*}}}*/
    167 
    168163                /*Deal with data needed to compute qmu responses: {{{1*/
    169164                for(i=0;i<iomodel->numresponsedescriptors;i++){

  • issm/trunk/src/c/modules/OutputResultsx/OutputResultsx.cpp

    r6441 r8224  
    4545        if(my_rank==0){
    4646                parameters->FindParam(&solutiontype,SolutionTypeEnum);
    47                 results->AddObject(new StringExternalResult(results->Size()+1,SolutionTypeEnum,EnumToString(solutiontype),1,0));
     47                results->AddObject(new StringExternalResult(results->Size()+1,SolutionTypeEnum,EnumToStringx(solutiontype),1,0));
    4848        }
    4949

  • issm/trunk/src/c/modules/Qmux/SpawnCoreParallel.cpp

    r6412 r8224  
    6666
    6767        /*Determine solution sequence: */
    68         _printf_(VerboseQmu(),"%s%s%s\n","Starting ",EnumToString(solution_type)," core:");
     68        _printf_(VerboseQmu(),"%s%s%s\n","Starting ",EnumToStringx(solution_type)," core:");
    6969        SolutionConfiguration(NULL,NULL,&solutioncore,solution_type);
    7070        if(control_analysis)solutioncore=&control_core;

  • issm/trunk/src/c/modules/Responsex/Responsex.cpp

    r6412 r8224  
    1818void Responsex(double* responses,Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads,Materials* materials, Parameters* parameters,char* response_descriptor,bool process_units){
    1919
    20         switch (StringToEnum(response_descriptor)){
     20        switch (StringToEnumx(response_descriptor)){
    2121               
    2222                case MinVelEnum: MinVelx( responses, elements,nodes, vertices, loads, materials, parameters,process_units); break;

  • issm/trunk/src/c/modules/modules.h

    r7666 r8224  
    2626#include "./DakotaResponsesx/DakotaResponsesx.h"
    2727#include "./ElementConnectivityx/ElementConnectivityx.h"
     28#include "./EnumToStringx/EnumToStringx.h"
     29#include "./StringToEnumx/StringToEnumx.h"
    2830#include "./GetSolutionFromInputsx/GetSolutionFromInputsx.h"
    2931#include "./GetVectorFromInputsx/GetVectorFromInputsx.h"

  • issm/trunk/src/c/objects/Constraints/Spc.cpp

    r5103 r8224  
    5050        printf("   dof: %i\n",dof);
    5151        printf("   value: %g\n",value);
    52         printf("   analysis_type: %s\n",EnumToString(analysis_type));
     52        printf("   analysis_type: %s\n",EnumToStringx(analysis_type));
    5353        return;
    5454}
    … …  
    6262        printf("   dof: %i\n",dof);
    6363        printf("   value: %g\n",value);
    64         printf("   analysis_type: %s\n",EnumToString(analysis_type));
     64        printf("   analysis_type: %s\n",EnumToStringx(analysis_type));
    6565        return;
    6666}               

  • issm/trunk/src/c/objects/DofIndexing.cpp

    r6412 r8224  
    141141                else this->sdoflist=NULL;
    142142        }
    143         else _error_("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!");
     143        else _error_("%s%s%s"," set of enum type ",EnumToStringx(setenum)," not supported yet!");
    144144
    145145

  • issm/trunk/src/c/objects/ElementResults/BoolElementResult.cpp

    r7077 r8224  
    4949
    5050        printf("BoolElementResult:\n");
    51         printf("   enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     51        printf("   enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    5252        printf("   value: %s\n",this->value?"true":"false");
    5353        printf("   step: %i\n",this->step);

  • issm/trunk/src/c/objects/ElementResults/DoubleElementResult.cpp

    r5529 r8224  
    4949
    5050        printf("DoubleElementResult:\n");
    51         printf("   enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     51        printf("   enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    5252        printf("   value: %g\n",this->value);
    5353        printf("   step: %i\n",this->step);

  • issm/trunk/src/c/objects/ElementResults/PentaVertexElementResult.cpp

    r6412 r8224  
    5151
    5252        printf("PentaVertexElementResult:\n");
    53         printf("   enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     53        printf("   enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    5454        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]);
    5555        printf("   step: %i\n",this->step);

  • issm/trunk/src/c/objects/ElementResults/TriaVertexElementResult.cpp

    r5529 r8224  
    5151               
    5252        printf("TriaVertexElementResult:\n");
    53         printf("   enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     53        printf("   enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    5454        printf("   values: [%g %g %g]\n",this->values[0],this->values[1],this->values[2]);
    5555        printf("   step: %i\n",this->step);

  • issm/trunk/src/c/objects/Elements/Penta.cpp

    r8129 r8224  
    482482                input=inputs->GetInput(enum_type);
    483483        }
    484         if (!input) _error_("Input %s not found",EnumToString(enum_type));
    485         if (input->Enum()!=ControlInputEnum) _error_("Input %s is not a ControlInput",EnumToString(enum_type));
     484        if (!input) _error_("Input %s not found",EnumToStringx(enum_type));
     485        if (input->Enum()!=ControlInputEnum) _error_("Input %s is not a ControlInput",EnumToStringx(enum_type));
    486486
    487487        this->GetDofList1(&doflist1[0]);
    … …  
    500500                input=inputs->GetInput(enum_type);
    501501        }
    502         if (!input) _error_("Input %s not found",EnumToString(enum_type));
    503         if (input->Enum()!=ControlInputEnum) _error_("Input %s is not a ControlInput",EnumToString(enum_type));
     502        if (!input) _error_("Input %s not found",EnumToStringx(enum_type));
     503        if (input->Enum()!=ControlInputEnum) _error_("Input %s is not a ControlInput",EnumToStringx(enum_type));
    504504
    505505        ((ControlInput*)input)->ScaleGradient(scale);
    … …  
    519519                input=inputs->GetInput(enum_type);
    520520        }
    521         if (!input) _error_("Input %s not found",EnumToString(enum_type));
    522         if (input->Enum()!=ControlInputEnum) _error_("Input %s is not a ControlInput",EnumToString(enum_type));
     521        if (!input) _error_("Input %s not found",EnumToStringx(enum_type));
     522        if (input->Enum()!=ControlInputEnum) _error_("Input %s is not a ControlInput",EnumToStringx(enum_type));
    523523
    524524        this->GetDofList1(&doflist1[0]);
    … …  
    574574                        break;
    575575                default:
    576                         _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
     576                        _error_("analysis %i (%s) not supported yet",analysis_type,EnumToStringx(analysis_type));
    577577        }
    578578
    … …  
    10081008                        return CreateKMatrixDiagnosticPattynStokes();
    10091009                default:
    1010                         _error_("Approximation %s not supported yet",EnumToString(approximation));
     1010                        _error_("Approximation %s not supported yet",EnumToStringx(approximation));
    10111011        }
    10121012}
    … …  
    11901190                        matice->GetViscosity3dStokes(&newviscosity,&epsilons[0]);
    11911191                }
    1192                 else _error_("approximation %i (%s) not supported yet",approximation,EnumToString(approximation));
     1192                else _error_("approximation %i (%s) not supported yet",approximation,EnumToStringx(approximation));
    11931193
    11941194                D_scalar=2*newviscosity*gauss->weight*Jdet;
    … …  
    19211921                        break;
    19221922                default:
    1923                         _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
     1923                        _error_("analysis %i (%s) not supported yet",analysis_type,EnumToStringx(analysis_type));
    19241924        }
    19251925
    … …  
    19471947                        return CreatePVectorAdjointStokes();
    19481948                default:
    1949                         _error_("Approximation %s not supported yet",EnumToString(approximation));
     1949                        _error_("Approximation %s not supported yet",EnumToStringx(approximation));
    19501950        }
    19511951}
    … …  
    23372337                        return CreatePVectorDiagnosticPattynStokes();
    23382338                default:
    2339                         _error_("Approximation %s not supported yet",EnumToString(approximation));
     2339                        _error_("Approximation %s not supported yet",EnumToStringx(approximation));
    23402340        }
    23412341}
    … …  
    30253025                GradjB(gradient);
    30263026        }
    3027         else _error_("control type %s not supported yet: ",EnumToString(control_type));
     3027        else _error_("control type %s not supported yet: ",EnumToStringx(control_type));
    30283028}
    30293029/*}}}*/
    … …  
    31033103                return;
    31043104        }
    3105         else _error_("approximation %s not supported yet",EnumToString(approximation));
     3105        else _error_("approximation %s not supported yet",EnumToStringx(approximation));
    31063106}
    31073107/*}}}*/
    … …  
    32053205        /*Recover input*/
    32063206        Input* input=inputs->GetInput(enumtype);
    3207         if (!input) _error_("Input %s not found in element",EnumToString(enumtype));
     3207        if (!input) _error_("Input %s not found in element",EnumToStringx(enumtype));
    32083208
    32093209        /*Checks in debugging mode*/
    … …  
    32543254
    32553255        Input* input=inputs->GetInput(enumtype);
    3256         if(!input) _error_("No input of type %s found in tria",EnumToString(enumtype));
     3256        if(!input) _error_("No input of type %s found in tria",EnumToStringx(enumtype));
    32573257
    32583258        GaussPenta* gauss=new GaussPenta();
    … …  
    33413341        }
    33423342        else{
    3343                 _error_("analysis: %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
     3343                _error_("analysis: %i (%s) not supported yet",analysis_type,EnumToStringx(analysis_type));
    33443344        }
    33453345}
    … …  
    36653665        /*Make a copy of the original input: */
    36663666        input=(Input*)this->inputs->GetInput(enum_type);
    3667         if(!input)_error_(" could not find old input with enum: %s",EnumToString(enum_type));
     3667        if(!input)_error_(" could not find old input with enum: %s",EnumToStringx(enum_type));
    36683668
    36693669        /*ArtificialNoise: */
    … …  
    36853685                new_inputs[i]=(Input*)this->inputs->GetInput(enums[2*i+0]);
    36863686                old_inputs[i]=(Input*)this->inputs->GetInput(enums[2*i+1]);
    3687                 if(!new_inputs[i])_error_("%s%s"," could not find input with enum ",EnumToString(enums[2*i+0]));
    3688                 if(!old_inputs[i])_error_("%s%s"," could not find input with enum ",EnumToString(enums[2*i+0]));
     3687                if(!new_inputs[i])_error_("%s%s"," could not find input with enum ",EnumToStringx(enums[2*i+0]));
     3688                if(!old_inputs[i])_error_("%s%s"," could not find input with enum ",EnumToStringx(enums[2*i+0]));
    36893689        }
    36903690
    … …  
    37253725                }
    37263726
    3727                 if (input->Enum()!=ControlInputEnum) _error_("input %s is not a ControlInput",EnumToString(control_type[i]));
     3727                if (input->Enum()!=ControlInputEnum) _error_("input %s is not a ControlInput",EnumToStringx(control_type[i]));
    37283728
    37293729                ((ControlInput*)input)->UpdateValue(scalar);
    … …  
    37743774                 original_input=(Input*)penta->matice->inputs->GetInput(enum_type);
    37753775                else
    3776                  _error_("object %s not supported yet",EnumToString(object_enum));
    3777                 if(!original_input) _error_("could not find input with enum %s",EnumToString(enum_type));
     3776                 _error_("object %s not supported yet",EnumToStringx(object_enum));
     3777                if(!original_input) _error_("could not find input with enum %s",EnumToStringx(enum_type));
    37783778
    37793779                /*If first time, initialize total_integrated_input*/
    … …  
    37863786                         total_integrated_input=new DoubleInput(average_enum_type,0.0);
    37873787                        else
    3788                          _error_("object %s not supported yet",EnumToString(original_input->Enum()));
     3788                         _error_("object %s not supported yet",EnumToStringx(original_input->Enum()));
    37893789                }
    37903790
    … …  
    38343834         this->matice->inputs->AddInput((Input*)depth_averaged_input);
    38353835        else
    3836          _error_("object %s not supported yet",EnumToString(object_enum));
     3836         _error_("object %s not supported yet",EnumToStringx(object_enum));
    38373837}
    38383838/*}}}*/
    … …  
    38643864                 original_input=(Input*)matice->inputs->GetInput(enum_type);
    38653865                else
    3866                  _error_("object of type %s not supported yet",EnumToString(object_type));
    3867                 if(!original_input) _error_("%s%s"," could not find input with enum:",EnumToString(enum_type));
     3866                 _error_("object of type %s not supported yet",EnumToStringx(object_type));
     3867                if(!original_input) _error_("%s%s"," could not find input with enum:",EnumToStringx(enum_type));
    38683868                original_input->Extrude();
    38693869
    … …  
    38873887                         penta->matice->inputs->AddInput((Input*)copy);
    38883888                        else
    3889                          _error_("object of type %s not supported yet",EnumToString(object_type));
     3889                         _error_("object of type %s not supported yet",EnumToStringx(object_type));
    38903890
    38913891                        /*Stop if we have reached the surface*/
    … …  
    39043904        /*Make a copy of the original input: */
    39053905        input=(Input*)this->inputs->GetInput(enum_type);
    3906         if(!input)_error_(" could not find old input with enum: %s",EnumToString(enum_type));
     3906        if(!input)_error_(" could not find old input with enum: %s",EnumToStringx(enum_type));
    39073907
    39083908        /*Scale: */
    … …  
    39203920        if (enum_type==RheologyBbarEnum) input=this->matice->inputs->GetInput(RheologyBEnum);
    39213921        else input=this->inputs->GetInput(enum_type);
    3922         if (!input) _error_("Input %s not found in penta->inputs",EnumToString(enum_type));
     3922        if (!input) _error_("Input %s not found in penta->inputs",EnumToStringx(enum_type));
    39233923
    39243924        /*If we don't find it, no big deal, just don't do the transfer. Otherwise, build a new Result
    … …  
    41024102                                        /*Matice will take care of it*/ break;
    41034103                                default:
    4104                                         _error_("Control %s not implemented yet",EnumToString((int)iomodel->control_type[i]));
     4104                                        _error_("Control %s not implemented yet",EnumToStringx((int)iomodel->control_type[i]));
    41054105                        }
    41064106                }
    … …  
    41344134                }
    41354135                else{
    4136                         _error_("Approximation type %s not supported yet",EnumToString((int)*(iomodel->elements_type+index)));
     4136                        _error_("Approximation type %s not supported yet",EnumToStringx((int)*(iomodel->elements_type+index)));
    41374137                }
    41384138        }
    … …  
    41964196        }
    41974197        else{
    4198                 _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
     4198                _error_("analysis %i (%s) not supported yet",analysis_type,EnumToStringx(analysis_type));
    41994199        }
    42004200}
    … …  
    42874287                Input* vz_input=inputs->GetInput(VzEnum);
    42884288                if (vz_input){
    4289                         if (vz_input->Enum()!=PentaVertexInputEnum) _error_("Cannot compute Vel as Vz is of type %s",EnumToString(vz_input->Enum()));
     4289                        if (vz_input->Enum()!=PentaVertexInputEnum) _error_("Cannot compute Vel as Vz is of type %s",EnumToStringx(vz_input->Enum()));
    42904290                        vz_input->GetValuesPtr(&vz_ptr,&dummy);
    42914291                        for(i=0;i<NUMVERTICES;i++) vz[i]=vz_ptr[i];
    … …  
    43784378        if (vz_input){
    43794379                if (vz_input->Enum()!=PentaVertexInputEnum){
    4380                         _error_("Cannot compute Vel as Vz is of type %s",EnumToString(vz_input->Enum()));
     4380                        _error_("Cannot compute Vel as Vz is of type %s",EnumToStringx(vz_input->Enum()));
    43814381                }
    43824382                vz_input->GetValuesPtr(&vz_ptr,&dummy);
    … …  
    44774477        if (vzmacayeal_input){
    44784478                if (vzmacayeal_input->Enum()!=PentaVertexInputEnum){
    4479                         _error_("Cannot compute Vel as VzMacAyeal is of type %s",EnumToString(vzmacayeal_input->Enum()));
     4479                        _error_("Cannot compute Vel as VzMacAyeal is of type %s",EnumToStringx(vzmacayeal_input->Enum()));
    44804480                }
    44814481                vzmacayeal_input->GetValuesPtr(&vzmacayeal_ptr,&dummy);
    … …  
    45534553        if (vz_input){
    45544554                if (vz_input->Enum()!=PentaVertexInputEnum){
    4555                         _error_("Cannot compute Vel as Vz is of type %s",EnumToString(vz_input->Enum()));
     4555                        _error_("Cannot compute Vel as Vz is of type %s",EnumToStringx(vz_input->Enum()));
    45564556                }
    45574557                vz_input->GetValuesPtr(&vz_ptr,&dummy);
    … …  
    46454645        if (vzpattyn_input){
    46464646                if (vzpattyn_input->Enum()!=PentaVertexInputEnum){
    4647                         _error_("Cannot compute Vel as VzPattyn is of type %s",EnumToString(vzpattyn_input->Enum()));
     4647                        _error_("Cannot compute Vel as VzPattyn is of type %s",EnumToStringx(vzpattyn_input->Enum()));
    46484648                }
    46494649                vzpattyn_input->GetValuesPtr(&vzpattyn_ptr,&dummy);
    … …  
    47214721        if (vz_input){
    47224722                if (vz_input->Enum()!=PentaVertexInputEnum){
    4723                         _error_("Cannot compute Vel as Vz is of type %s",EnumToString(vz_input->Enum()));
     4723                        _error_("Cannot compute Vel as Vz is of type %s",EnumToStringx(vz_input->Enum()));
    47244724                }
    47254725                vz_input->GetValuesPtr(&vz_ptr,&dummy);
    … …  
    48034803        Input* vx_input=inputs->GetInput(VxEnum);
    48044804        if (vx_input){
    4805                 if (vx_input->Enum()!=PentaVertexInputEnum) _error_("Cannot compute Vel as Vx is of type %s",EnumToString(vx_input->Enum()));
     4805                if (vx_input->Enum()!=PentaVertexInputEnum) _error_("Cannot compute Vel as Vx is of type %s",EnumToStringx(vx_input->Enum()));
    48064806                vx_input->GetValuesPtr(&vx_ptr,&dummy);
    48074807                for(i=0;i<NUMVERTICES;i++) vx[i]=vx_ptr[i];
    … …  
    48114811        Input* vy_input=inputs->GetInput(VyEnum);
    48124812        if (vy_input){
    4813                 if (vy_input->Enum()!=PentaVertexInputEnum) _error_("Cannot compute Vel as Vy is of type %s",EnumToString(vy_input->Enum()));
     4813                if (vy_input->Enum()!=PentaVertexInputEnum) _error_("Cannot compute Vel as Vy is of type %s",EnumToStringx(vy_input->Enum()));
    48144814                vy_input->GetValuesPtr(&vy_ptr,&dummy);
    48154815                for(i=0;i<NUMVERTICES;i++) vy[i]=vy_ptr[i];
    … …  
    48214821                Input* vzstokes_input=inputs->GetInput(VzStokesEnum);
    48224822                if (vzstokes_input){
    4823                         if (vzstokes_input->Enum()!=PentaVertexInputEnum) _error_("Cannot compute Vel as VzStokes is of type %s",EnumToString(vy_input->Enum()));
     4823                        if (vzstokes_input->Enum()!=PentaVertexInputEnum) _error_("Cannot compute Vel as VzStokes is of type %s",EnumToStringx(vy_input->Enum()));
    48244824                        vzstokes_input->GetValuesPtr(&vzstokes_ptr,&dummy);
    48254825                        for(i=0;i<NUMVERTICES;i++) vzstokes[i]=vzstokes_ptr[i];
    … …  
    48344834                Input* vzstokes_input=inputs->GetInput(VzStokesEnum);
    48354835                if (vzstokes_input){
    4836                         if (vzstokes_input->Enum()!=PentaVertexInputEnum) _error_("Cannot compute Vel as VzStokes is of type %s",EnumToString(vy_input->Enum()));
     4836                        if (vzstokes_input->Enum()!=PentaVertexInputEnum) _error_("Cannot compute Vel as VzStokes is of type %s",EnumToStringx(vy_input->Enum()));
    48374837                        vzstokes_input->GetValuesPtr(&vzstokes_ptr,&dummy);
    48384838                        for(i=0;i<NUMVERTICES;i++) vzstokes[i]=vzstokes_ptr[i];
    … …  
    50775077                                        bed[i]=bed_ptr[i]-rho_ice/rho_water*(values[i]-thickness_ptr[i]); //bed = oldbed + di * dH
    50785078                        }
    5079                         else _error_("Hydrostatic adjustment %i (%s) not supported yet",hydroadjustment,EnumToString(hydroadjustment));
     5079                        else _error_("Hydrostatic adjustment %i (%s) not supported yet",hydroadjustment,EnumToStringx(hydroadjustment));
    50805080                }
    50815081        }
    … …  
    51555155                                break;
    51565156                        default:
    5157                                 _error_("Rheology law %s not supported yet",EnumToString(rheology_law));
     5157                                _error_("Rheology law %s not supported yet",EnumToStringx(rheology_law));
    51585158
    51595159                }
    … …  
    52575257                default:
    52585258
    5259                         _error_("type %i (%s) not implemented yet",type,EnumToString(type));
     5259                        _error_("type %i (%s) not implemented yet",type,EnumToStringx(type));
    52605260        }
    52615261}

  • issm/trunk/src/c/objects/Elements/Tria.cpp

    r8129 r8224  
    418418                        break;
    419419                default:
    420                         _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
     420                        _error_("analysis %i (%s) not supported yet",analysis_type,EnumToStringx(analysis_type));
    421421        }
    422422
    … …  
    442442                        break;
    443443                default:
    444                         _error_("Element type %s not supported yet",EnumToString(GetElementType()));
     444                        _error_("Element type %s not supported yet",EnumToStringx(GetElementType()));
    445445        }
    446446
    … …  
    459459                        return CreateKMatrixBalancedthickness_DG();
    460460                default:
    461                         _error_("Element type %s not supported yet",EnumToString(GetElementType()));
     461                        _error_("Element type %s not supported yet",EnumToStringx(GetElementType()));
    462462        }
    463463
    … …  
    12751275                        return CreateKMatrixPrognostic_DG();
    12761276                default:
    1277                         _error_("Element type %s not supported yet",EnumToString(GetElementType()));
     1277                        _error_("Element type %s not supported yet",EnumToStringx(GetElementType()));
    12781278        }
    12791279
    … …  
    16281628                        break;
    16291629                default:
    1630                         _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
     1630                        _error_("analysis %i (%s) not supported yet",analysis_type,EnumToStringx(analysis_type));
    16311631        }
    16321632
    … …  
    16481648                        return CreatePVectorBalancedthickness_DG();
    16491649                default:
    1650                         _error_("Element type %s not supported yet",EnumToString(GetElementType()));
     1650                        _error_("Element type %s not supported yet",EnumToStringx(GetElementType()));
    16511651        }
    16521652}
    … …  
    21052105        else{
    21062106                /*Not supported yet! : */
    2107                 _error_("response %s not supported yet",EnumToString(response));
     2107                _error_("response %s not supported yet",EnumToStringx(response));
    21082108        }
    21092109
    … …  
    22852285        else{
    22862286                /*Not supported yet! : */
    2287                 _error_("response %s not supported yet",EnumToString(response));
     2287                _error_("response %s not supported yet",EnumToStringx(response));
    22882288        }
    22892289
    … …  
    23762376                        return CreatePVectorPrognostic_DG();
    23772377                default:
    2378                         _error_("Element type %s not supported yet",EnumToString(GetElementType()));
     2378                        _error_("Element type %s not supported yet",EnumToStringx(GetElementType()));
    23792379        }
    23802380}
    … …  
    27402740                input=inputs->GetInput(enum_type);
    27412741        }
    2742         if (!input) _error_("Input %s not found",EnumToString(enum_type));
    2743         if (input->Enum()!=ControlInputEnum) _error_("Input %s is not a ControlInput",EnumToString(enum_type));
     2742        if (!input) _error_("Input %s not found",EnumToStringx(enum_type));
     2743        if (input->Enum()!=ControlInputEnum) _error_("Input %s is not a ControlInput",EnumToStringx(enum_type));
    27442744
    27452745        this->GetDofList1(&doflist1[0]);
    … …  
    27582758                input=inputs->GetInput(enum_type);
    27592759        }
    2760         if (!input) _error_("Input %s not found",EnumToString(enum_type));
    2761         if (input->Enum()!=ControlInputEnum) _error_("Input %s is not a ControlInput",EnumToString(enum_type));
     2760        if (!input) _error_("Input %s not found",EnumToStringx(enum_type));
     2761        if (input->Enum()!=ControlInputEnum) _error_("Input %s is not a ControlInput",EnumToStringx(enum_type));
    27622762
    27632763        ((ControlInput*)input)->ScaleGradient(scale);
    … …  
    27772777                input=inputs->GetInput(enum_type);
    27782778        }
    2779         if (!input) _error_("Input %s not found",EnumToString(enum_type));
    2780         if (input->Enum()!=ControlInputEnum) _error_("Input %s is not a ControlInput",EnumToString(enum_type));
     2779        if (!input) _error_("Input %s not found",EnumToStringx(enum_type));
     2780        if (input->Enum()!=ControlInputEnum) _error_("Input %s is not a ControlInput",EnumToStringx(enum_type));
    27812781
    27822782        this->GetDofList1(&doflist1[0]);
    … …  
    29532953        /*Recover input*/
    29542954        Input* input=inputs->GetInput(enumtype);
    2955         if (!input) _error_("Input %s not found in element",EnumToString(enumtype));
     2955        if (!input) _error_("Input %s not found in element",EnumToStringx(enumtype));
    29562956
    29572957        /*Checks in debugging mode*/
    … …  
    29992999
    30003000        Input* input=inputs->GetInput(enumtype);
    3001         if(!input) _error_("No input of type %s found in tria",EnumToString(enumtype));
     3001        if(!input) _error_("No input of type %s found in tria",EnumToStringx(enumtype));
    30023002
    30033003        GaussTria* gauss=new GaussTria();
    … …  
    30313031         GetSolutionFromInputsHydrology(solution);
    30323032        else
    3033          _error_("analysis: %s not supported yet",EnumToString(analysis_type));
     3033         _error_("analysis: %s not supported yet",EnumToStringx(analysis_type));
    30343034
    30353035}
    … …  
    36493649        /*Make a copy of the original input: */
    36503650        input=(Input*)this->inputs->GetInput(enum_type);
    3651         if(!input)_error_(" could not find old input with enum: %s",EnumToString(enum_type));
     3651        if(!input)_error_(" could not find old input with enum: %s",EnumToStringx(enum_type));
    36523652
    36533653        /*ArtificialNoise: */
    … …  
    36773677
    36783678                if (input->Enum()!=ControlInputEnum){
    3679                         _error_("input %s is not a ControlInput",EnumToString(control_type[i]));
     3679                        _error_("input %s is not a ControlInput",EnumToStringx(control_type[i]));
    36803680                }
    36813681
    … …  
    37043704                new_inputs[i]=(Input*)this->inputs->GetInput(enums[2*i+0]);
    37053705                old_inputs[i]=(Input*)this->inputs->GetInput(enums[2*i+1]);
    3706                 if(!new_inputs[i])_error_("%s%s"," could not find input with enum ",EnumToString(enums[2*i+0]));
    3707                 if(!old_inputs[i])_error_("%s%s"," could not find input with enum ",EnumToString(enums[2*i+0]));
     3706                if(!new_inputs[i])_error_("%s%s"," could not find input with enum ",EnumToStringx(enums[2*i+0]));
     3707                if(!old_inputs[i])_error_("%s%s"," could not find input with enum ",EnumToStringx(enums[2*i+0]));
    37083708        }
    37093709
    … …  
    37333733         oldinput=(Input*)this->matice->inputs->GetInput(enum_type);
    37343734        else
    3735          _error_("object %s not supported yet",EnumToString(object_enum));
    3736         if(!oldinput)_error_("%s%s"," could not find old input with enum: ",EnumToString(enum_type));
     3735         _error_("object %s not supported yet",EnumToStringx(object_enum));
     3736        if(!oldinput)_error_("%s%s"," could not find old input with enum: ",EnumToStringx(enum_type));
    37373737        newinput=(Input*)oldinput->copy();
    37383738
    … …  
    37463746         this->matice->inputs->AddInput((Input*)newinput);
    37473747        else
    3748          _error_("object %s not supported yet",EnumToString(object_enum));
     3748         _error_("object %s not supported yet",EnumToStringx(object_enum));
    37493749}
    37503750/*}}}*/
    … …  
    37643764        /*Make a copy of the original input: */
    37653765        input=(Input*)this->inputs->GetInput(enum_type);
    3766         if(!input)_error_(" could not find old input with enum: %s",EnumToString(enum_type));
     3766        if(!input)_error_(" could not find old input with enum: %s",EnumToStringx(enum_type));
    37673767
    37683768        /*Scale: */
    … …  
    37793779        if (enum_type==RheologyBbarEnum) input=this->matice->inputs->GetInput(enum_type);
    37803780        else input=this->inputs->GetInput(enum_type);
    3781         if (!input) _error_("Input %s not found in tria->inputs",EnumToString(enum_type));
     3781        if (!input) _error_("Input %s not found in tria->inputs",EnumToStringx(enum_type));
    37823782
    37833783        /*If we don't find it, no big deal, just don't do the transfer. Otherwise, build a new Result
    … …  
    39803980                                        /*Matice will take care of it*/ break;
    39813981                                default:
    3982                                         _error_("Control %s not implemented yet",EnumToString((int)iomodel->control_type[i]));
     3982                                        _error_("Control %s not implemented yet",EnumToStringx((int)iomodel->control_type[i]));
    39833983                        }
    39843984                }
    … …  
    40324032                        break;
    40334033                default:
    4034                         _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
     4034                        _error_("analysis %i (%s) not supported yet",analysis_type,EnumToStringx(analysis_type));
    40354035        }
    40364036}
    … …  
    42004200        if (vz_input){
    42014201                if (vz_input->Enum()!=TriaVertexInputEnum){
    4202                         _error_("Cannot compute Vel as Vz is of type %s",EnumToString(vz_input->Enum()));
     4202                        _error_("Cannot compute Vel as Vz is of type %s",EnumToStringx(vz_input->Enum()));
    42034203                }
    42044204                vz_input->GetValuesPtr(&vz_ptr,&dummy);
    … …  
    43174317                                bed[i]=bed_ptr[i]-rho_ice/rho_water*(values[i]-thickness_ptr[i]); //bed = oldbed + di * dH
    43184318                        }
    4319                         else _error_("Hydrostatic adjustment %i (%s) not supported yet",hydroadjustment,EnumToString(hydroadjustment));
     4319                        else _error_("Hydrostatic adjustment %i (%s) not supported yet",hydroadjustment,EnumToStringx(hydroadjustment));
    43204320                }
    43214321        }
    … …  
    43894389
    43904390                default:
    4391                         _error_("type %i (%s) not implemented yet",type,EnumToString(type));
     4391                        _error_("type %i (%s) not implemented yet",type,EnumToStringx(type));
    43924392        }
    43934393}
    … …  
    45004500
    45014501                default:
    4502                         _error_("type %i (%s) not implemented yet",type,EnumToString(type));
     4502                        _error_("type %i (%s) not implemented yet",type,EnumToStringx(type));
    45034503        }
    45044504
    … …  
    50465046                        }
    50475047                        else{
    5048                                 _error_("unsupported control type: %s",EnumToString(control_type[i]));
     5048                                _error_("unsupported control type: %s",EnumToStringx(control_type[i]));
    50495049                        }
    50505050                }

  • issm/trunk/src/c/objects/ExternalResults/BoolExternalResult.cpp

    r6389 r8224  
    5353        printf("BoolExternalResult:\n");
    5454        printf("   id: %i\n",this->id);
    55         printf("   enum:  %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     55        printf("   enum:  %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    5656        printf("   value: %s\n",this->value?"true":"false");
    5757        printf("   step: %i\n",this->step);
    … …  
    156156
    157157        /*First write enum: */
    158         name=EnumToString(this->enum_type);
     158        name=EnumToStringx(this->enum_type);
    159159        length=(strlen(name)+1)*sizeof(char);
    160160        fwrite(&length,sizeof(int),1,fid);
    … …  
    179179/*FUNCTION BoolExternalResult::GetResultName{{{1*/
    180180char* BoolExternalResult::GetResultName(void){
    181         return  EnumToString(this->enum_type);
     181        return  EnumToStringx(this->enum_type);
    182182}
    183183/*}}}*/

  • issm/trunk/src/c/objects/ExternalResults/DoubleExternalResult.cpp

    r6389 r8224  
    5353        printf("DoubleExternalResult:\n");
    5454        printf("   id: %i\n",this->id);
    55         printf("   enum:  %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     55        printf("   enum:  %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    5656        printf("   value: %g\n",this->value);
    5757        printf("   step: %i\n",this->step);
    … …  
    155155
    156156        /*First write enum: */
    157         name=EnumToString(this->enum_type);
     157        name=EnumToStringx(this->enum_type);
    158158        length=(strlen(name)+1)*sizeof(char);
    159159        fwrite(&length,sizeof(int),1,fid);
    … …  
    175175/*FUNCTION DoubleExternalResult::GetResultName{{{1*/
    176176char* DoubleExternalResult::GetResultName(void){
    177         return  EnumToString(this->enum_type);
     177        return  EnumToStringx(this->enum_type);
    178178}
    179179/*}}}*/

  • issm/trunk/src/c/objects/ExternalResults/DoubleMatExternalResult.cpp

    r6389 r8224  
    5858
    5959        printf("DoubleMatExternalResult:\n");
    60         printf("   enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     60        printf("   enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    6161        printf("   step: %i\n",this->step);
    6262        printf("   time: %g\n",this->time);
    … …  
    7272        printf("DoubleMatExternalResult:\n");
    7373        printf("   id: %i\n",this->id);
    74         printf("   enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     74        printf("   enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    7575        printf("   step: %i\n",this->step);
    7676        printf("   time: %g\n",this->time);
    … …  
    194194
    195195        /*First write enum: */
    196         name=EnumToString(this->enum_type);
     196        name=EnumToStringx(this->enum_type);
    197197        length=(strlen(name)+1)*sizeof(char);
    198198        fwrite(&length,sizeof(int),1,fid);
    … …  
    216216/*FUNCTION DoubleMatExternalResult::GetResultName{{{1*/
    217217char* DoubleMatExternalResult::GetResultName(void){
    218         return  EnumToString(this->enum_type);
     218        return  EnumToStringx(this->enum_type);
    219219}
    220220/*}}}*/

  • issm/trunk/src/c/objects/ExternalResults/DoubleVecExternalResult.cpp

    r6389 r8224  
    5555
    5656        printf("DoubleVecExternalResult:\n");
    57         printf("   enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     57        printf("   enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    5858        printf("   vector size: %i\n",this->M);
    5959        printf("   step: %i\n",this->step);
    … …  
    6969        printf("DoubleVecExternalResult:\n");
    7070        printf("   id: %i\n",this->id);
    71         printf("   enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     71        printf("   enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    7272        printf("   vector size: %i\n",this->M);
    7373        for(i=0;i<this->M;i++){
    … …  
    180180
    181181        /*First write enum: */
    182         name=EnumToString(this->enum_type);
     182        name=EnumToStringx(this->enum_type);
    183183        length=(strlen(name)+1)*sizeof(char);
    184184        fwrite(&length,sizeof(int),1,fid);
    … …  
    200200/*FUNCTION DoubleVecExternalResult::GetResultName{{{1*/
    201201char* DoubleVecExternalResult::GetResultName(void){
    202         return  EnumToString(this->enum_type);
     202        return  EnumToStringx(this->enum_type);
    203203}
    204204/*}}}*/

  • issm/trunk/src/c/objects/ExternalResults/IntExternalResult.cpp

    r6389 r8224  
    5353        printf("IntExternalResult:\n");
    5454        printf("   id: %i\n",this->id);
    55         printf("   enum:  %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     55        printf("   enum:  %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    5656        printf("   value: %i\n",this->value);
    5757        printf("   step: %i\n",this->step);
    … …  
    156156
    157157        /*First write enum: */
    158         name=EnumToString(this->enum_type);
     158        name=EnumToStringx(this->enum_type);
    159159        length=(strlen(name)+1)*sizeof(char);
    160160        fwrite(&length,sizeof(int),1,fid);
    … …  
    179179/*FUNCTION IntExternalResult::GetResultName{{{1*/
    180180char* IntExternalResult::GetResultName(void){
    181         return  EnumToString(this->enum_type);
     181        return  EnumToStringx(this->enum_type);
    182182}
    183183/*}}}*/

  • issm/trunk/src/c/objects/ExternalResults/PetscVecExternalResult.cpp

    r6389 r8224  
    5555
    5656        printf("PetscVecExternalResult:\n");
    57         printf("   enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     57        printf("   enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    5858
    5959}
    … …  
    6565        printf("PetscVecExternalResult:\n");
    6666        printf("   id: %i\n",this->id);
    67         printf("   enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     67        printf("   enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    6868        printf("   step: %i\n",this->step);
    6969        printf("   time: %g\n",this->time);
    … …  
    215215
    216216        /*First write enum: */
    217         name=EnumToString(this->enum_type);
     217        name=EnumToStringx(this->enum_type);
    218218        length=(strlen(name)+1)*sizeof(char);
    219219        fwrite(&length,sizeof(int),1,fid);
    … …  
    237237/*FUNCTION PetscVecExternalResult::GetResultName{{{1*/
    238238char* PetscVecExternalResult::GetResultName(void){
    239         return  EnumToString(this->enum_type);
     239        return  EnumToStringx(this->enum_type);
    240240}
    241241/*}}}*/

  • issm/trunk/src/c/objects/ExternalResults/StringExternalResult.cpp

    r6389 r8224  
    5555        printf("StringExternalResult:\n");
    5656        printf("   id: %i\n",this->id);
    57         printf("   enum:  %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     57        printf("   enum:  %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    5858        printf("   value: %s\n",this->value);
    5959        printf("   step: %i\n",this->step);
    … …  
    169169
    170170        /*First write enum: */
    171         name=EnumToString(this->enum_type);
     171        name=EnumToStringx(this->enum_type);
    172172        length=(strlen(name)+1)*sizeof(char);
    173173        fwrite(&length,sizeof(int),1,fid);
    … …  
    190190/*FUNCTION StringExternalResult::GetResultName{{{1*/
    191191char* StringExternalResult::GetResultName(void){
    192         return  EnumToString(this->enum_type);
     192        return  EnumToStringx(this->enum_type);
    193193}
    194194/*}}}*/

  • issm/trunk/src/c/objects/FemModel.cpp

    r6412 r8224  
    5353        for(i=0;i<nummodels;i++){
    5454
    55                 _printf_(VerboseMProcessor(),"   Processing finite element model of analysis %s:\n",EnumToString(analysis_type_list[i]));
     55                _printf_(VerboseMProcessor(),"   Processing finite element model of analysis %s:\n",EnumToStringx(analysis_type_list[i]));
    5656                analysis_type=analysis_type_list[i];
    5757                this->SetCurrentConfiguration(analysis_type);
    … …  
    127127        printf("   number of fem models: %i\n",nummodels);
    128128        printf("   analysis_type_list: \n");
    129         for(int i=0;i<nummodels;i++)printf("     %i: %s\n",i,EnumToString(analysis_type_list[i]));
     129        for(int i=0;i<nummodels;i++)printf("     %i: %s\n",i,EnumToStringx(analysis_type_list[i]));
    130130        printf("   current analysis_type: \n");
    131         printf("     %i: %s\n",analysis_counter,EnumToString(analysis_type_list[analysis_counter]));
     131        printf("     %i: %s\n",analysis_counter,EnumToStringx(analysis_type_list[analysis_counter]));
    132132
    133133
    … …  
    152152        }
    153153        if(found!=-1) analysis_counter=found;
    154         else _error_("Could not find alias for analysis_type %s in list of FemModel analyses",EnumToString(configuration_type));
     154        else _error_("Could not find alias for analysis_type %s in list of FemModel analyses",EnumToStringx(configuration_type));
    155155
    156156        /*activate matrices/vectors: */
    … …  
    170170        /*take care of petsc options, that depend on this analysis type: */
    171171        PetscOptionsFromAnalysis(this->parameters,analysis_type);
    172         _printf_(VerboseSolver(),"      petsc Options set for analysis type: %s\n",EnumToString(analysis_type));
     172        _printf_(VerboseSolver(),"      petsc Options set for analysis type: %s\n",EnumToStringx(analysis_type));
    173173
    174174}

  • issm/trunk/src/c/objects/Inputs/BoolInput.cpp

    r7089 r8224  
    4646
    4747        printf("BoolInput:\n");
    48         printf("   enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     48        printf("   enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    4949        printf("   value: %s\n",value?"true":"false");
    5050}

  • issm/trunk/src/c/objects/Inputs/ControlInput.cpp

    r8129 r8224  
    4848                        break;
    4949                default:
    50                         _error_("Input of Enum %s not supported yet by ControlInput",EnumToString(enum_input));
     50                        _error_("Input of Enum %s not supported yet by ControlInput",EnumToStringx(enum_input));
    5151        }
    5252        gradient   =NULL;
    … …  
    7373
    7474        printf("ControlInput:\n");
    75         printf("   enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     75        printf("   enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    7676        printf("---values: \n");     if (values)      values->Echo();
    7777        printf("---savedvalues: \n");if (savedvalues) savedvalues->Echo();
    … …  
    358358/*FUNCTION ControlInput::ScaleGradient{{{1*/
    359359void ControlInput::ScaleGradient(double scaling_factor){
    360         if(!gradient) _error_("Gradient of ControlInput %s not found",EnumToString(enum_type));
     360        if(!gradient) _error_("Gradient of ControlInput %s not found",EnumToStringx(enum_type));
    361361        gradient->Scale(scaling_factor);
    362362}/*}}}*/
    … …  
    430430/*FUNCTION ControlInput::SaveValue{{{1*/
    431431void ControlInput::SaveValue(void){
    432         if(!values) _error_("Values of %s not found",EnumToString(this->enum_type));
     432        if(!values) _error_("Values of %s not found",EnumToStringx(this->enum_type));
    433433
    434434        if(savedvalues) delete this->savedvalues;
    … …  
    437437/*FUNCTION ControlInput::UpdateValue{{{1*/
    438438void ControlInput::UpdateValue(double scalar){
    439         if(!gradient)    _error_("Gradient of %s not found",EnumToString(this->enum_type));
    440         if(!savedvalues) _error_("Values of %s not found",EnumToString(this->enum_type));
     439        if(!gradient)    _error_("Gradient of %s not found",EnumToStringx(this->enum_type));
     440        if(!savedvalues) _error_("Values of %s not found",EnumToStringx(this->enum_type));
    441441
    442442        if(values) delete this->values;

  • issm/trunk/src/c/objects/Inputs/DoubleInput.cpp

    r8129 r8224  
    4646
    4747        printf("DoubleInput:\n");
    48         printf("   enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     48        printf("   enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    4949        printf("   value: %g\n",this->value);
    5050}
    … …  
    160160        *pvalue=(bool)value;
    161161#else
    162         _error_("Double input of enum %s cannot return a boolean",EnumToString(enum_type));
     162        _error_("Double input of enum %s cannot return a boolean",EnumToStringx(enum_type));
    163163#endif
    164164
    … …  
    170170        *pvalue=(int)value;
    171171#else
    172         _error_("Double input of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));
     172        _error_("Double input of enum %i (%s) cannot return an integer",enum_type,EnumToStringx(enum_type));
    173173#endif
    174174
    … …  
    291291
    292292        /*Check that input provided is a thickness*/
    293         if (thickness_input->EnumType()!=ThicknessEnum) _error_("Input provided is not a Thickness (enum_type is %s)",EnumToString(thickness_input->EnumType()));
     293        if (thickness_input->EnumType()!=ThicknessEnum) _error_("Input provided is not a Thickness (enum_type is %s)",EnumToStringx(thickness_input->EnumType()));
    294294
    295295        /*vertically integrate depending on type:*/

  • issm/trunk/src/c/objects/Inputs/IntInput.cpp

    r6412 r8224  
    4141
    4242        printf("IntInput:\n");
    43         printf("   enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     43        printf("   enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    4444        printf("   value: %i\n",(int)this->value);
    4545}

  • issm/trunk/src/c/objects/Inputs/PentaVertexInput.cpp

    r8129 r8224  
    5757
    5858        printf("PentaVertexInput:\n");
    59         printf("   enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     59        printf("   enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    6060        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]);
    6161}
    … …  
    545545
    546546        /*Check that input provided is a thickness*/
    547         if (thickness_input->EnumType()!=ThicknessEnum) _error_("Input provided is not a Thickness (enum_type is %s)",EnumToString(thickness_input->EnumType()));
     547        if (thickness_input->EnumType()!=ThicknessEnum) _error_("Input provided is not a Thickness (enum_type is %s)",EnumToStringx(thickness_input->EnumType()));
    548548
    549549        /*Get Thickness value pointer*/
    … …  
    579579
    580580        /*Check that inputB is of the same type*/
    581         if (inputB->Enum()!=PentaVertexInputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToString(inputB->Enum()));
     581        if (inputB->Enum()!=PentaVertexInputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->Enum()));
    582582        xinputB=(PentaVertexInput*)inputB;
    583583
    … …  
    610610
    611611        /*Check that inputB is of the same type*/
    612         if (inputB->Enum()!=PentaVertexInputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToString(inputB->Enum()));
     612        if (inputB->Enum()!=PentaVertexInputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->Enum()));
    613613        xinputB=(PentaVertexInput*)inputB;
    614614
    … …  
    641641
    642642        /*Check that inputB is of the same type*/
    643         if (inputB->Enum()!=PentaVertexInputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToString(inputB->Enum()));
     643        if (inputB->Enum()!=PentaVertexInputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->Enum()));
    644644        xinputB=(PentaVertexInput*)inputB;
    645645

  • issm/trunk/src/c/objects/Inputs/TriaVertexInput.cpp

    r8129 r8224  
    5757
    5858        printf("TriaVertexInput:\n");
    59         printf("   enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     59        printf("   enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    6060        printf("   values: [%g %g %g]\n",this->values[0],this->values[1],this->values[2]);
    6161}
    … …  
    417417
    418418        /*Check that inputB is of the same type*/
    419         if (inputB->Enum()!=TriaVertexInputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToString(inputB->Enum()));
     419        if (inputB->Enum()!=TriaVertexInputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->Enum()));
    420420        xinputB=(TriaVertexInput*)inputB;
    421421
    … …  
    448448
    449449        /*Check that inputB is of the same type*/
    450         if (inputB->Enum()!=TriaVertexInputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToString(inputB->Enum()));
     450        if (inputB->Enum()!=TriaVertexInputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToStringx(inputB->Enum()));
    451451        xinputB=(TriaVertexInput*)inputB;
    452452

  • issm/trunk/src/c/objects/Loads/Friction.cpp

    r7922 r8224  
    4949void Friction::Echo(void){
    5050        printf("Friction:\n");
    51         printf("   analysis_type: %s\n",EnumToString(analysis_type));
     51        printf("   analysis_type: %s\n",EnumToStringx(analysis_type));
    5252        printf("   element_type: %s\n",this->element_type);
    5353        inputs->Echo();
    … …  
    251251
    252252        Input* input=inputs->GetInput(enum_type);
    253         if(!input) _error_("input %s not found",EnumToString(enum_type));
     253        if(!input) _error_("input %s not found",EnumToStringx(enum_type));
    254254        input->GetParameterValue(pvalue,gauss);
    255255
    … …  
    260260
    261261        Input* input=inputs->GetInput(enum_type);
    262         if(!input) _error_("input %s not found",EnumToString(enum_type));
     262        if(!input) _error_("input %s not found",EnumToStringx(enum_type));
    263263        input->GetParameterValue(pvalue,gauss);
    264264

  • issm/trunk/src/c/objects/Loads/Icefront.cpp

    r7306 r8224  
    7474                icefront_node_ids[3]=iomodel->nodecounter+(int)*(iomodel->pressureload+segment_width*i+3);
    7575        }
    76         else _error_("in_icefront_type %s not supported yet!",EnumToString(in_icefront_type));
     76        else _error_("in_icefront_type %s not supported yet!",EnumToStringx(in_icefront_type));
    7777
    7878        if (in_icefront_type==PattynIceFrontEnum || in_icefront_type==StokesIceFrontEnum) num_nodes=4;
    … …  
    118118        printf("Icefront:\n");
    119119        printf("   id: %i\n",id);
    120         printf("   analysis_type: %s\n",EnumToString(analysis_type));
     120        printf("   analysis_type: %s\n",EnumToStringx(analysis_type));
    121121        hnodes->Echo();
    122122        helement->Echo();
    … …  
    133133        printf("Icefront:\n");
    134134        printf("   id: %i\n",id);
    135         printf("   analysis_type: %s\n",EnumToString(analysis_type));
     135        printf("   analysis_type: %s\n",EnumToStringx(analysis_type));
    136136        hnodes->DeepEcho();
    137137        helement->DeepEcho();
    … …  
    334334                        break;
    335335                default:
    336                         _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
     336                        _error_("analysis %i (%s) not supported yet",analysis_type,EnumToStringx(analysis_type));
    337337        }
    338338
    … …  
    432432                        return CreatePVectorDiagnosticStokes();
    433433                default:
    434                         _error_("Icefront type %s not supported yet",EnumToString(type));
     434                        _error_("Icefront type %s not supported yet",EnumToStringx(type));
    435435        }
    436436}
    … …  
    490490                switch(fill){
    491491                        case WaterEnum:
    492                                 surface_under_water=min(0,thickness+bed); // 0 if the top of the glacier is above water level
    493                                 base_under_water=min(0,bed);              // 0 if the bottom of the glacier is above water level
     492                                surface_under_water=min(0.,thickness+bed); // 0 if the top of the glacier is above water level
     493                                base_under_water=min(0.,bed);              // 0 if the bottom of the glacier is above water level
    494494                                water_pressure=1.0/2.0*gravity*rho_water*(pow(surface_under_water,2) - pow(base_under_water,2));
    495495                                break;
    … …  
    501501                                break;
    502502                        default:
    503                                 _error_("fill type %s not supported yet",EnumToString(fill));
     503                                _error_("fill type %s not supported yet",EnumToStringx(fill));
    504504                }
    505505                ice_pressure=1.0/2.0*gravity*rho_ice*pow(thickness,2);
    … …  
    603603                switch(fill){
    604604                        case WaterEnum:
    605                                 water_pressure=rho_water*gravity*min(0,z_g);//0 if the gaussian point is above water level
     605                                water_pressure=rho_water*gravity*min(0.,z_g);//0 if the gaussian point is above water level
    606606                                break;
    607607                        case AirEnum:
    … …  
    609609                                break;
    610610                        default:
    611                                 _error_("fill type %s not supported yet",EnumToString(fill));
     611                                _error_("fill type %s not supported yet",EnumToStringx(fill));
    612612                }
    613613                ice_pressure=rho_ice*gravity*(surface-z_g);
    … …  
    674674                switch(fill){
    675675                        case WaterEnum:
    676                                 water_pressure=rho_water*gravity*min(0,z_g);//0 if the gaussian point is above water level
     676                                water_pressure=rho_water*gravity*min(0.,z_g);//0 if the gaussian point is above water level
    677677                                break;
    678678                        case AirEnum:
    … …  
    680680                                break;
    681681                        default:
    682                                 _error_("fill type %s not supported yet",EnumToString(fill));
     682                                _error_("fill type %s not supported yet",EnumToStringx(fill));
    683683                }
    684684                air_pressure=0;

  • issm/trunk/src/c/objects/Loads/Numericalflux.cpp

    r6413 r8224  
    148148        printf("Numericalflux:\n");
    149149        printf("   id: %i\n",id);
    150         printf("   analysis_type: %s\n",EnumToString(analysis_type));
     150        printf("   analysis_type: %s\n",EnumToStringx(analysis_type));
    151151        hnodes->Echo();
    152152        helement->Echo();
    … …  
    160160        printf("Numericalflux:\n");
    161161        printf("   id: %i\n",id);
    162         printf("   analysis_type: %s\n",EnumToString(analysis_type));
     162        printf("   analysis_type: %s\n",EnumToStringx(analysis_type));
    163163        hnodes->DeepEcho();
    164164        helement->DeepEcho();
    … …  
    346346                        break;
    347347                default:
    348                         _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
     348                        _error_("analysis %i (%s) not supported yet",analysis_type,EnumToStringx(analysis_type));
    349349        }
    350350
    … …  
    376376                        break;
    377377                default:
    378                         _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
     378                        _error_("analysis %i (%s) not supported yet",analysis_type,EnumToStringx(analysis_type));
    379379        }
    380380

  • issm/trunk/src/c/objects/Loads/Pengrid.cpp

    r8073 r8224  
    104104        printf("Pengrid:\n");
    105105        printf("   id: %i\n",id);
    106         printf("   analysis_type: %s\n",EnumToString(analysis_type));
     106        printf("   analysis_type: %s\n",EnumToStringx(analysis_type));
    107107        hnode->DeepEcho();
    108108        helement->DeepEcho();
    … …  
    320320                        break;
    321321                default:
    322                         _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
     322                        _error_("analysis %i (%s) not supported yet",analysis_type,EnumToStringx(analysis_type));
    323323        }
    324324
    … …  
    348348                        break;
    349349                default:
    350                         _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
     350                        _error_("analysis %i (%s) not supported yet",analysis_type,EnumToStringx(analysis_type));
    351351        }
    352352
    … …  
    451451        }
    452452        else{
    453                 _error_("analysis: %s not supported yet",EnumToString(analysis_type));
     453                _error_("analysis: %s not supported yet",EnumToStringx(analysis_type));
    454454        }
    455455

  • issm/trunk/src/c/objects/Loads/Penpair.cpp

    r7833 r8224  
    5959        printf("Penpair:\n");
    6060        printf("   id: %i\n",id);
    61         printf("   analysis_type: %s\n",EnumToString(analysis_type));
     61        printf("   analysis_type: %s\n",EnumToStringx(analysis_type));
    6262        hnodes->Echo();
    6363       
    … …  
    7070        printf("Penpair:\n");
    7171        printf("   id: %i\n",id);
    72         printf("   analysis_type: %s\n",EnumToString(analysis_type));
     72        printf("   analysis_type: %s\n",EnumToStringx(analysis_type));
    7373        hnodes->DeepEcho();
    7474
    … …  
    228228                        break;
    229229                default:
    230                         _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
     230                        _error_("analysis %i (%s) not supported yet",analysis_type,EnumToStringx(analysis_type));
    231231        }
    232232

  • issm/trunk/src/c/objects/Loads/Riftfront.cpp

    r7089 r8224  
    139139        printf("Riftfront:\n");
    140140        printf("   id: %i\n",id);
    141         printf("   analysis_type: %s\n",EnumToString(analysis_type));
     141        printf("   analysis_type: %s\n",EnumToStringx(analysis_type));
    142142        printf("   hnodes: %p\n",hnodes);
    143143        printf("   helements: %p\n",helements);
    … …  
    167167        printf("Riftfront:\n");
    168168        printf("   id: %i\n",id);
    169         printf("   analysis_type: %s\n",EnumToString(analysis_type));
     169        printf("   analysis_type: %s\n",EnumToStringx(analysis_type));
    170170        hnodes->DeepEcho();
    171171        helements->DeepEcho();
    … …  
    435435                        break;
    436436                default:
    437                         _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
     437                        _error_("analysis %i (%s) not supported yet",analysis_type,EnumToStringx(analysis_type));
    438438        }
    439439
    … …  
    461461                        break;
    462462                default:
    463                         _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
     463                        _error_("analysis %i (%s) not supported yet",analysis_type,EnumToStringx(analysis_type));
    464464        }
    465465

  • issm/trunk/src/c/objects/Materials/Matice.cpp

    r8129 r8224  
    521521                                        return;
    522522
    523                                 default: _error_("element %s not implemented yet",EnumToString(element->Enum()));
    524                         }
    525                 default: _error_("type %i (%s) not implemented yet",type,EnumToString(type));
     523                                default: _error_("element %s not implemented yet",EnumToStringx(element->Enum()));
     524                        }
     525                default: _error_("type %i (%s) not implemented yet",type,EnumToStringx(type));
    526526        }
    527527}
    … …  
    561561                                        return;
    562562
    563                                 default: _error_("element %s not implemented yet",EnumToString(element->Enum()));
    564                         }
    565                 default: _error_("type %i (%s) not implemented yet",type,EnumToString(type));
     563                                default: _error_("element %s not implemented yet",EnumToStringx(element->Enum()));
     564                        }
     565                default: _error_("type %i (%s) not implemented yet",type,EnumToStringx(type));
    566566        }
    567567}

  • issm/trunk/src/c/objects/Node.cpp

    r7515 r8224  
    174174        printf("   id: %i\n",id);
    175175        printf("   sid: %i\n",sid);
    176         printf("   analysis_type: %s\n",EnumToString(analysis_type));
     176        printf("   analysis_type: %s\n",EnumToStringx(analysis_type));
    177177        indexing.Echo();
    178178        printf("   hvertex:     not displayed\n");
    … …  
    188188        printf("   id: %i\n",id);
    189189        printf("   sid: %i\n",sid);
    190         printf("   analysis_type: %s\n",EnumToString(analysis_type));
     190        printf("   analysis_type: %s\n",EnumToStringx(analysis_type));
    191191        indexing.DeepEcho();
    192192        printf("Vertex:\n");
    … …  
    328328                return indexing.sdoflist[dofindex];
    329329        }
    330         else _error_("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!");
     330        else _error_("%s%s%s"," set of enum type ",EnumToStringx(setenum)," not supported yet!");
    331331
    332332}
    … …  
    400400                        else for(i=0;i<this->indexing.ssize;i++) outdoflist[i]=indexing.sdoflist[i];
    401401                }
    402                 else _error_("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!");
     402                else _error_("%s%s%s"," set of enum type ",EnumToStringx(setenum)," not supported yet!");
    403403        }
    404404}
    … …  
    440440                        }
    441441                }
    442                 else _error_("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!");
     442                else _error_("%s%s%s"," set of enum type ",EnumToStringx(setenum)," not supported yet!");
    443443        }
    444444        else{
    … …  
    509509                        }
    510510                }
    511                 else _error_("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!");
     511                else _error_("%s%s%s"," set of enum type ",EnumToStringx(setenum)," not supported yet!");
    512512        }
    513513}
    … …  
    668668                else if (setenum==FsetEnum) numdofs=this->indexing.fsize;
    669669                else if (setenum==SsetEnum) numdofs=this->indexing.ssize;
    670                 else _error_("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!");
     670                else _error_("%s%s%s"," set of enum type ",EnumToStringx(setenum)," not supported yet!");
    671671        }
    672672        else{
    … …  
    698698                        else numdofs=this->indexing.ssize;
    699699                }
    700                 else _error_("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!");
     700                else _error_("%s%s%s"," set of enum type ",EnumToStringx(setenum)," not supported yet!");
    701701        }
    702702        return numdofs;
    … …  
    881881                dofcount+=this->indexing.ssize;
    882882        }
    883         else _error_("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!");
     883        else _error_("%s%s%s"," set of enum type ",EnumToStringx(setenum)," not supported yet!");
    884884
    885885
    … …  
    910910                for(i=0;i<this->indexing.ssize;i++) indexing.sdoflist[i]+=dofcount;
    911911        }
    912         else _error_("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!");
     912        else _error_("%s%s%s"," set of enum type ",EnumToStringx(setenum)," not supported yet!");
    913913}
    914914/*}}}*/
    … …  
    926926        else if(setenum==FsetEnum)for(j=0;j<this->indexing.fsize;j++)  *(truedofs+ncols*sid+j)=indexing.fdoflist[j];
    927927        else if(setenum==SsetEnum)for(j=0;j<this->indexing.ssize;j++)  *(truedofs+ncols*sid+j)=indexing.sdoflist[j];
    928         else _error_("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!");
     928        else _error_("%s%s%s"," set of enum type ",EnumToStringx(setenum)," not supported yet!");
    929929
    930930}
    … …  
    945945        else if(setenum==FsetEnum)for(j=0;j<this->indexing.fsize;j++) indexing.fdoflist[j]=*(alltruedofs+ncols*sid+j);
    946946        else if(setenum==SsetEnum)for(j=0;j<this->indexing.ssize;j++) indexing.sdoflist[j]=*(alltruedofs+ncols*sid+j);
    947         else _error_("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!");
     947        else _error_("%s%s%s"," set of enum type ",EnumToStringx(setenum)," not supported yet!");
    948948
    949949}

  • issm/trunk/src/c/objects/Params/BoolParam.cpp

    r5103 r8224  
    4949
    5050        printf("BoolParam:\n");
    51         printf("   enum:  %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     51        printf("   enum:  %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    5252        printf("   value: %s\n",this->value?"true":"false");
    5353}
    … …  
    129129/*FUNCTION BoolParam::GetParameterName{{{1*/
    130130char* BoolParam::GetParameterName(void){
    131         return  EnumToString(this->enum_type);
     131        return  EnumToStringx(this->enum_type);
    132132}
    133133/*}}}*/

  • issm/trunk/src/c/objects/Params/BoolParam.h

    r6412 r8224  
    5050                int   EnumType(){return enum_type;}
    5151                void  GetParameterValue(bool* pbool){*pbool=value;}
    52                 void  GetParameterValue(int* pinteger){_error_("Bool param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));}
    53                 void  GetParameterValue(int** pintarray,int* pM){_error_("Bool param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));}
    54                 void  GetParameterValue(double* pdouble){_error_("Bool param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
    55                 void  GetParameterValue(char** pstring){_error_("Bool param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));}
    56                 void  GetParameterValue(char*** pstringarray,int* pM){_error_("Bool param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));}
    57                 void  GetParameterValue(double** pdoublearray,int* pM){_error_("Bool param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
    58                 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));}
    59                 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));}
    60                 void  GetParameterValue(Vec* pvec){_error_("Bool param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));}
    61                 void  GetParameterValue(Mat* pmat){_error_("Bool param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));}
    62                 void  GetParameterValue(FILE** pfid){_error_("Bool param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));}
     52                void  GetParameterValue(int* pinteger){_error_("Bool param of enum %i (%s) cannot return an integer",enum_type,EnumToStringx(enum_type));}
     53                void  GetParameterValue(int** pintarray,int* pM){_error_("Bool param of enum %i (%s) cannot return an array of integers",enum_type,EnumToStringx(enum_type));}
     54                void  GetParameterValue(double* pdouble){_error_("Bool param of enum %i (%s) cannot return a double",enum_type,EnumToStringx(enum_type));}
     55                void  GetParameterValue(char** pstring){_error_("Bool param of enum %i (%s) cannot return a string",enum_type,EnumToStringx(enum_type));}
     56                void  GetParameterValue(char*** pstringarray,int* pM){_error_("Bool param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToStringx(enum_type));}
     57                void  GetParameterValue(double** pdoublearray,int* pM){_error_("Bool param of enum %i (%s) cannot return a double array",enum_type,EnumToStringx(enum_type));}
     58                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));}
     59                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));}
     60                void  GetParameterValue(Vec* pvec){_error_("Bool param of enum %i (%s) cannot return a Vec",enum_type,EnumToStringx(enum_type));}
     61                void  GetParameterValue(Mat* pmat){_error_("Bool param of enum %i (%s) cannot return a Mat",enum_type,EnumToStringx(enum_type));}
     62                void  GetParameterValue(FILE** pfid){_error_("Bool param of enum %i (%s) cannot return a FILE",enum_type,EnumToStringx(enum_type));}
    6363
    6464                void  SetValue(bool boolean){this->value=boolean;}
    6565                void  SetValue(int integer){this->value=(bool)integer;}
    66                 void  SetValue(int* intarray,int M){_error_("Bool param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));}
     66                void  SetValue(int* intarray,int M){_error_("Bool param of enum %i (%s) cannot hold an int array",enum_type,EnumToStringx(enum_type));}
    6767                void  SetValue(double scalar){this->value=(bool)scalar;}
    68                 void  SetValue(char* string){_error_("Bool param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
    69                 void  SetValue(char** stringarray,int M){_error_("Bool param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));}
    70                 void  SetValue(double* doublearray,int M){_error_("Bool param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
    71                 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));}
    72                 void  SetValue(Vec vec){_error_("Bool param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));}
    73                 void  SetValue(Mat mat){_error_("Bool param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));}
    74                 void  SetValue(FILE* fid){_error_("Bool param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
    75                 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));}
     68                void  SetValue(char* string){_error_("Bool param of enum %i (%s) cannot hold a string",enum_type,EnumToStringx(enum_type));}
     69                void  SetValue(char** stringarray,int M){_error_("Bool param of enum %i (%s) cannot hold a string array",enum_type,EnumToStringx(enum_type));}
     70                void  SetValue(double* doublearray,int M){_error_("Bool param of enum %i (%s) cannot hold a double array",enum_type,EnumToStringx(enum_type));}
     71                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));}
     72                void  SetValue(Vec vec){_error_("Bool param of enum %i (%s) cannot hold a Vec",enum_type,EnumToStringx(enum_type));}
     73                void  SetValue(Mat mat){_error_("Bool param of enum %i (%s) cannot hold a Mat",enum_type,EnumToStringx(enum_type));}
     74                void  SetValue(FILE* fid){_error_("Bool param of enum %i (%s) cannot hold a FILE",enum_type,EnumToStringx(enum_type));}
     75                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));}
    7676               
    7777                char* GetParameterName(void);

  • issm/trunk/src/c/objects/Params/DoubleMatArrayParam.cpp

    r5103 r8224  
    8888
    8989        printf("DoubleMatArrayParam:\n");
    90         printf("   enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     90        printf("   enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    9191        printf("   array size: %i\n",this->M);
    9292        printf("   array pointer: %p\n",this->array);
    … …  
    102102       
    103103        printf("DoubleMatArrayParam:\n");
    104         printf("   enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     104        printf("   enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    105105        printf("   array size: %i\n",this->M);
    106106        for(i=0;i<M;i++){
    … …  
    303303/*FUNCTION DoubleMatArrayParam::GetParameterName{{{1*/
    304304char* DoubleMatArrayParam::GetParameterName(void){
    305         return  EnumToString(this->enum_type);
     305        return  EnumToStringx(this->enum_type);
    306306}
    307307/*}}}*/

  • issm/trunk/src/c/objects/Params/DoubleMatArrayParam.h

    r6412 r8224  
    5252                /*Param vritual function definitions: {{{1*/
    5353                int   EnumType(){return enum_type;}
    54                 void  GetParameterValue(bool* pbool){_error_("DoubleMatArray param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));}
    55                 void  GetParameterValue(int* pinteger){_error_("DoubleMatArray param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));}
    56                 void  GetParameterValue(int** pintarray,int* pM){_error_("DoubleMatArray param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));}
    57                 void  GetParameterValue(double* pdouble){_error_("DoubleMatArray param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
    58                 void  GetParameterValue(char** pstring){_error_("DoubleMatArray param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));}
    59                 void  GetParameterValue(char*** pstringarray,int* pM){_error_("DoubleMatArray param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));}
    60                 void  GetParameterValue(double** pdoublearray,int* pM){_error_("DoubleMatArray param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
    61                 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));}
     54                void  GetParameterValue(bool* pbool){_error_("DoubleMatArray param of enum %i (%s) cannot return a bool",enum_type,EnumToStringx(enum_type));}
     55                void  GetParameterValue(int* pinteger){_error_("DoubleMatArray param of enum %i (%s) cannot return an integer",enum_type,EnumToStringx(enum_type));}
     56                void  GetParameterValue(int** pintarray,int* pM){_error_("DoubleMatArray param of enum %i (%s) cannot return an array of integers",enum_type,EnumToStringx(enum_type));}
     57                void  GetParameterValue(double* pdouble){_error_("DoubleMatArray param of enum %i (%s) cannot return a double",enum_type,EnumToStringx(enum_type));}
     58                void  GetParameterValue(char** pstring){_error_("DoubleMatArray param of enum %i (%s) cannot return a string",enum_type,EnumToStringx(enum_type));}
     59                void  GetParameterValue(char*** pstringarray,int* pM){_error_("DoubleMatArray param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToStringx(enum_type));}
     60                void  GetParameterValue(double** pdoublearray,int* pM){_error_("DoubleMatArray param of enum %i (%s) cannot return a double array",enum_type,EnumToStringx(enum_type));}
     61                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));}
    6262                void  GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims);
    63                 void  GetParameterValue(Vec* pvec){_error_("DoubleMatArray param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));}
    64                 void  GetParameterValue(Mat* pmat){_error_("DoubleMatArray param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));}
    65                 void  GetParameterValue(FILE** pfid){_error_("DoubleMatArray param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));}
     63                void  GetParameterValue(Vec* pvec){_error_("DoubleMatArray param of enum %i (%s) cannot return a Vec",enum_type,EnumToStringx(enum_type));}
     64                void  GetParameterValue(Mat* pmat){_error_("DoubleMatArray param of enum %i (%s) cannot return a Mat",enum_type,EnumToStringx(enum_type));}
     65                void  GetParameterValue(FILE** pfid){_error_("DoubleMatArray param of enum %i (%s) cannot return a FILE",enum_type,EnumToStringx(enum_type));}
    6666
    67                 void  SetValue(bool boolean){_error_("DoubleMatArray param of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));}
    68                 void  SetValue(int integer){_error_("DoubleMatArray param of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));}
    69                 void  SetValue(int* intarray,int M){_error_("DoubleMatArray param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));}
    70                 void  SetValue(double scalar){_error_("DoubleMatArray param of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));}
    71                 void  SetValue(char* string){_error_("DoubleMatArray param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
    72                 void  SetValue(char** stringarray,int M){_error_("DoubleMatArray param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));}
    73                 void  SetValue(double* doublearray,int M){_error_("DoubleMatArray param of enum %i (%s) cannot hold a double vec array",enum_type,EnumToString(enum_type));}
    74                 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));}
    75                 void  SetValue(Vec vec){_error_("DoubleMatArray param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));}
    76                 void  SetValue(Mat mat){_error_("DoubleMatArray param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));}
    77                 void  SetValue(FILE* fid){_error_("Bool param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
     67                void  SetValue(bool boolean){_error_("DoubleMatArray param of enum %i (%s) cannot hold a boolean",enum_type,EnumToStringx(enum_type));}
     68                void  SetValue(int integer){_error_("DoubleMatArray param of enum %i (%s) cannot hold an integer",enum_type,EnumToStringx(enum_type));}
     69                void  SetValue(int* intarray,int M){_error_("DoubleMatArray param of enum %i (%s) cannot hold an int array",enum_type,EnumToStringx(enum_type));}
     70                void  SetValue(double scalar){_error_("DoubleMatArray param of enum %i (%s) cannot hold a scalar",enum_type,EnumToStringx(enum_type));}
     71                void  SetValue(char* string){_error_("DoubleMatArray param of enum %i (%s) cannot hold a string",enum_type,EnumToStringx(enum_type));}
     72                void  SetValue(char** stringarray,int M){_error_("DoubleMatArray param of enum %i (%s) cannot hold a string array",enum_type,EnumToStringx(enum_type));}
     73                void  SetValue(double* doublearray,int M){_error_("DoubleMatArray param of enum %i (%s) cannot hold a double vec array",enum_type,EnumToStringx(enum_type));}
     74                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));}
     75                void  SetValue(Vec vec){_error_("DoubleMatArray param of enum %i (%s) cannot hold a Vec",enum_type,EnumToStringx(enum_type));}
     76                void  SetValue(Mat mat){_error_("DoubleMatArray param of enum %i (%s) cannot hold a Mat",enum_type,EnumToStringx(enum_type));}
     77                void  SetValue(FILE* fid){_error_("Bool param of enum %i (%s) cannot hold a FILE",enum_type,EnumToStringx(enum_type));}
    7878                void  SetValue(double** array, int M, int* mdim_array, int* ndim_array);
    7979

  • issm/trunk/src/c/objects/Params/DoubleMatParam.cpp

    r6163 r8224  
    4949
    5050        printf("DoubleMatParam:\n");
    51         printf("   enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     51        printf("   enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    5252        printf("   matrix size: %ix%i\n",this->M,this->N);
    5353
    … …  
    6060       
    6161        printf("DoubleMatParam:\n");
    62         printf("   enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     62        printf("   enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    6363        printf("   matrix size: %ix%i\n",this->M,this->N);
    6464        for(i=0;i<this->M;i++){
    … …  
    167167/*FUNCTION DoubleMatParam::GetParameterName{{{1*/
    168168char* DoubleMatParam::GetParameterName(void){
    169         return  EnumToString(this->enum_type);
     169        return  EnumToStringx(this->enum_type);
    170170}
    171171/*}}}*/

  • issm/trunk/src/c/objects/Params/DoubleMatParam.h

    r6412 r8224  
    5151                /*Param vritual function definitions: {{{1*/
    5252                int   EnumType(){return enum_type;}
    53                 void  GetParameterValue(bool* pbool){_error_("DoubleMat param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));}
    54                 void  GetParameterValue(int* pinteger){_error_("DoubleMat param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));}
    55                 void  GetParameterValue(int** pintarray,int* pM){_error_("DoubleMat param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));}
    56                 void  GetParameterValue(double* pdouble){_error_("DoubleMat param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
    57                 void  GetParameterValue(char** pstring){_error_("DoubleMat param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));}
    58                 void  GetParameterValue(char*** pstringarray,int* pM){_error_("DoubleMat param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));}
    59                 void  GetParameterValue(double** pdoublearray,int* pM){_error_("DoubleMat param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
     53                void  GetParameterValue(bool* pbool){_error_("DoubleMat param of enum %i (%s) cannot return a bool",enum_type,EnumToStringx(enum_type));}
     54                void  GetParameterValue(int* pinteger){_error_("DoubleMat param of enum %i (%s) cannot return an integer",enum_type,EnumToStringx(enum_type));}
     55                void  GetParameterValue(int** pintarray,int* pM){_error_("DoubleMat param of enum %i (%s) cannot return an array of integers",enum_type,EnumToStringx(enum_type));}
     56                void  GetParameterValue(double* pdouble){_error_("DoubleMat param of enum %i (%s) cannot return a double",enum_type,EnumToStringx(enum_type));}
     57                void  GetParameterValue(char** pstring){_error_("DoubleMat param of enum %i (%s) cannot return a string",enum_type,EnumToStringx(enum_type));}
     58                void  GetParameterValue(char*** pstringarray,int* pM){_error_("DoubleMat param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToStringx(enum_type));}
     59                void  GetParameterValue(double** pdoublearray,int* pM){_error_("DoubleMat param of enum %i (%s) cannot return a double array",enum_type,EnumToStringx(enum_type));}
    6060                void  GetParameterValue(double** pdoublearray,int* pM,int* pN);
    61                 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));}
    62                 void  GetParameterValue(Vec* pvec){_error_("DoubleMat param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));}
    63                 void  GetParameterValue(Mat* pmat){_error_("DoubleMat param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));}
    64                 void  GetParameterValue(FILE** pfid){_error_("DoubleMat param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));}
     61                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));}
     62                void  GetParameterValue(Vec* pvec){_error_("DoubleMat param of enum %i (%s) cannot return a Vec",enum_type,EnumToStringx(enum_type));}
     63                void  GetParameterValue(Mat* pmat){_error_("DoubleMat param of enum %i (%s) cannot return a Mat",enum_type,EnumToStringx(enum_type));}
     64                void  GetParameterValue(FILE** pfid){_error_("DoubleMat param of enum %i (%s) cannot return a FILE",enum_type,EnumToStringx(enum_type));}
    6565
    66                 void  SetValue(bool boolean){_error_("DoubleMat param of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));}
    67                 void  SetValue(int integer){_error_("DoubleMat param of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));}
    68                 void  SetValue(int* intarray,int M){_error_("DoubleMat param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));}
    69                 void  SetValue(double scalar){_error_("DoubleMat param of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));}
    70                 void  SetValue(char* string){_error_("DoubleMat param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
    71                 void  SetValue(char** stringarray,int M){_error_("DoubleMat param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));}
    72                 void  SetValue(double* doublearray,int M){_error_("DoubleMat param of enum %i (%s) cannot hold a double vec array",enum_type,EnumToString(enum_type));}
     66                void  SetValue(bool boolean){_error_("DoubleMat param of enum %i (%s) cannot hold a boolean",enum_type,EnumToStringx(enum_type));}
     67                void  SetValue(int integer){_error_("DoubleMat param of enum %i (%s) cannot hold an integer",enum_type,EnumToStringx(enum_type));}
     68                void  SetValue(int* intarray,int M){_error_("DoubleMat param of enum %i (%s) cannot hold an int array",enum_type,EnumToStringx(enum_type));}
     69                void  SetValue(double scalar){_error_("DoubleMat param of enum %i (%s) cannot hold a scalar",enum_type,EnumToStringx(enum_type));}
     70                void  SetValue(char* string){_error_("DoubleMat param of enum %i (%s) cannot hold a string",enum_type,EnumToStringx(enum_type));}
     71                void  SetValue(char** stringarray,int M){_error_("DoubleMat param of enum %i (%s) cannot hold a string array",enum_type,EnumToStringx(enum_type));}
     72                void  SetValue(double* doublearray,int M){_error_("DoubleMat param of enum %i (%s) cannot hold a double vec array",enum_type,EnumToStringx(enum_type));}
    7373                void  SetValue(double* doublearray,int M,int N);
    74                 void  SetValue(Vec vec){_error_("DoubleMat param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));}
    75                 void  SetValue(Mat mat){_error_("DoubleMat param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));}
    76                 void  SetValue(FILE* fid){_error_("DoubleMat param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
    77                 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));}
     74                void  SetValue(Vec vec){_error_("DoubleMat param of enum %i (%s) cannot hold a Vec",enum_type,EnumToStringx(enum_type));}
     75                void  SetValue(Mat mat){_error_("DoubleMat param of enum %i (%s) cannot hold a Mat",enum_type,EnumToStringx(enum_type));}
     76                void  SetValue(FILE* fid){_error_("DoubleMat param of enum %i (%s) cannot hold a FILE",enum_type,EnumToStringx(enum_type));}
     77                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));}
    7878
    7979                char* GetParameterName(void);

  • issm/trunk/src/c/objects/Params/DoubleParam.cpp

    r6412 r8224  
    4646
    4747        printf("DoubleParam:\n");
    48         printf("   enum:  %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     48        printf("   enum:  %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    4949        printf("   value: %g\n",this->value);
    5050}
    … …  
    126126/*FUNCTION DoubleParam::GetParameterName{{{1*/
    127127char* DoubleParam::GetParameterName(void){
    128         return  EnumToString(this->enum_type);
     128        return  EnumToStringx(this->enum_type);
    129129}
    130130/*}}}*/
    … …  
    134134        *pinteger=(int)value;
    135135#else
    136         _error_("Double param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));
     136        _error_("Double param of enum %i (%s) cannot return an integer",enum_type,EnumToStringx(enum_type));
    137137#endif
    138138}
    … …  
    147147
    148148#else
    149         _error_("Double param of enum %i (%s) cannot return an bool",enum_type,EnumToString(enum_type));
     149        _error_("Double param of enum %i (%s) cannot return an bool",enum_type,EnumToStringx(enum_type));
    150150#endif
    151151}
    … …  
    163163        *pintarray=output;
    164164#else
    165         _error_("Double param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));
     165        _error_("Double param of enum %i (%s) cannot return an array of integers",enum_type,EnumToStringx(enum_type));
    166166#endif
    167167}
    … …  
    179179        *pdoublearray=output;
    180180#else
    181         _error_("Double param of enum %i (%s) cannot return an array of double",enum_type,EnumToString(enum_type));
     181        _error_("Double param of enum %i (%s) cannot return an array of double",enum_type,EnumToStringx(enum_type));
    182182#endif
    183183}
    … …  
    196196        *pdoublearray=output;
    197197#else
    198         _error_("Double param of enum %i (%s) cannot return an array of double",enum_type,EnumToString(enum_type));
     198        _error_("Double param of enum %i (%s) cannot return an array of double",enum_type,EnumToStringx(enum_type));
    199199#endif
    200200}

  • issm/trunk/src/c/objects/Params/DoubleParam.h

    r6412 r8224  
    5454                void  GetParameterValue(int** pintarray,int* pM);
    5555                void  GetParameterValue(double* pdouble){*pdouble=value;}
    56                 void  GetParameterValue(char** pstring){_error_("Double param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));}
    57                 void  GetParameterValue(char*** pstringarray,int* pM){_error_("Double param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));}
     56                void  GetParameterValue(char** pstring){_error_("Double param of enum %i (%s) cannot return a string",enum_type,EnumToStringx(enum_type));}
     57                void  GetParameterValue(char*** pstringarray,int* pM){_error_("Double param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToStringx(enum_type));}
    5858                void  GetParameterValue(double** pdoublearray,int* pM);
    5959                void  GetParameterValue(double** pdoublearray,int* pM, int* pN);
    60                 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));}
    61                 void  GetParameterValue(Vec* pvec){_error_("Double param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));}
    62                 void  GetParameterValue(Mat* pmat){_error_("Double param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));}
    63                 void  GetParameterValue(FILE** pfid){_error_("Double param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));}
     60                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));}
     61                void  GetParameterValue(Vec* pvec){_error_("Double param of enum %i (%s) cannot return a Vec",enum_type,EnumToStringx(enum_type));}
     62                void  GetParameterValue(Mat* pmat){_error_("Double param of enum %i (%s) cannot return a Mat",enum_type,EnumToStringx(enum_type));}
     63                void  GetParameterValue(FILE** pfid){_error_("Double param of enum %i (%s) cannot return a FILE",enum_type,EnumToStringx(enum_type));}
    6464
    6565                void  SetValue(bool boolean){this->value=(double)boolean;}
    6666                void  SetValue(int integer){this->value=(double)integer;}
    67                 void  SetValue(int* intarray,int M){_error_("Double param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));}
     67                void  SetValue(int* intarray,int M){_error_("Double param of enum %i (%s) cannot hold an int array",enum_type,EnumToStringx(enum_type));}
    6868                void  SetValue(double scalar){this->value=(double)scalar;}
    69                 void  SetValue(char* string){_error_("Double param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
    70                 void  SetValue(char** stringarray,int M){_error_("Double param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));}
    71                 void  SetValue(double* doublearray,int M){_error_("Double param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
    72                 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));}
    73                 void  SetValue(Vec vec){_error_("Double param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));}
    74                 void  SetValue(Mat mat){_error_("Double param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));}
    75                 void  SetValue(FILE* fid){_error_("Double param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
    76                 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));}
     69                void  SetValue(char* string){_error_("Double param of enum %i (%s) cannot hold a string",enum_type,EnumToStringx(enum_type));}
     70                void  SetValue(char** stringarray,int M){_error_("Double param of enum %i (%s) cannot hold a string array",enum_type,EnumToStringx(enum_type));}
     71                void  SetValue(double* doublearray,int M){_error_("Double param of enum %i (%s) cannot hold a double array",enum_type,EnumToStringx(enum_type));}
     72                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));}
     73                void  SetValue(Vec vec){_error_("Double param of enum %i (%s) cannot hold a Vec",enum_type,EnumToStringx(enum_type));}
     74                void  SetValue(Mat mat){_error_("Double param of enum %i (%s) cannot hold a Mat",enum_type,EnumToStringx(enum_type));}
     75                void  SetValue(FILE* fid){_error_("Double param of enum %i (%s) cannot hold a FILE",enum_type,EnumToStringx(enum_type));}
     76                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));}
    7777
    7878                char* GetParameterName(void);

  • issm/trunk/src/c/objects/Params/DoubleVecParam.cpp

    r6412 r8224  
    4848
    4949        printf("DoubleVecParam:\n");
    50         printf("   enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     50        printf("   enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    5151        printf("   vector size: %i\n",this->M);
    5252
    … …  
    5959       
    6060        printf("DoubleVecParam:\n");
    61         printf("   enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     61        printf("   enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    6262        printf("   vector size: %i\n",this->M);
    6363        for(i=0;i<this->M;i++){
    … …  
    174174        *pintarray=output;
    175175#else
    176         _error_("Double param of enum %i (%s) cannot return an array of double",enum_type,EnumToString(enum_type));
     176        _error_("Double param of enum %i (%s) cannot return an array of double",enum_type,EnumToStringx(enum_type));
    177177#endif
    178178}
    … …  
    180180/*FUNCTION DoubleVecParam::GetParameterName{{{1*/
    181181char* DoubleVecParam::GetParameterName(void){
    182         return  EnumToString(this->enum_type);
     182        return  EnumToStringx(this->enum_type);
    183183}
    184184/*}}}*/

  • issm/trunk/src/c/objects/Params/DoubleVecParam.h

    r6412 r8224  
    5050                /*Param virtual functions definitions: {{{1*/
    5151                int   EnumType(){return enum_type;}
    52                 void  GetParameterValue(bool* pbool){_error_("DoubleVec param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));}
    53                 void  GetParameterValue(int* pinteger){_error_("DoubleVec param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));}
     52                void  GetParameterValue(bool* pbool){_error_("DoubleVec param of enum %i (%s) cannot return a bool",enum_type,EnumToStringx(enum_type));}
     53                void  GetParameterValue(int* pinteger){_error_("DoubleVec param of enum %i (%s) cannot return an integer",enum_type,EnumToStringx(enum_type));}
    5454                void  GetParameterValue(int** pintarray,int* pM);
    55                 void  GetParameterValue(double* pdouble){_error_("DoubleVec param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
    56                 void  GetParameterValue(char** pstring){_error_("DoubleVec param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));}
    57                 void  GetParameterValue(char*** pstringarray,int* pM){_error_("DoubleVec param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));}
     55                void  GetParameterValue(double* pdouble){_error_("DoubleVec param of enum %i (%s) cannot return a double",enum_type,EnumToStringx(enum_type));}
     56                void  GetParameterValue(char** pstring){_error_("DoubleVec param of enum %i (%s) cannot return a string",enum_type,EnumToStringx(enum_type));}
     57                void  GetParameterValue(char*** pstringarray,int* pM){_error_("DoubleVec param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToStringx(enum_type));}
    5858                void  GetParameterValue(double** pdoublearray,int* pM);
    59                 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));}
    60                 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));}
    61                 void  GetParameterValue(Vec* pvec){_error_("DoubleVec param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));}
    62                 void  GetParameterValue(Mat* pmat){_error_("DoubleVec param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));}
    63                 void  GetParameterValue(FILE** pfid){_error_("DoubleVec param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));}
     59                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));}
     60                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));}
     61                void  GetParameterValue(Vec* pvec){_error_("DoubleVec param of enum %i (%s) cannot return a Vec",enum_type,EnumToStringx(enum_type));}
     62                void  GetParameterValue(Mat* pmat){_error_("DoubleVec param of enum %i (%s) cannot return a Mat",enum_type,EnumToStringx(enum_type));}
     63                void  GetParameterValue(FILE** pfid){_error_("DoubleVec param of enum %i (%s) cannot return a FILE",enum_type,EnumToStringx(enum_type));}
    6464
    65                 void  SetValue(bool boolean){_error_("DoubleVec param of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));}
    66                 void  SetValue(int integer){_error_("DoubleVec param of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));}
    67                 void  SetValue(int* intarray,int M){_error_("DoubleVec param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));}
    68                 void  SetValue(double scalar){_error_("DoubleVec param of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));}
    69                 void  SetValue(char* string){_error_("DoubleVec param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
    70                 void  SetValue(char** stringarray,int M){_error_("DoubleVec param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));}
     65                void  SetValue(bool boolean){_error_("DoubleVec param of enum %i (%s) cannot hold a boolean",enum_type,EnumToStringx(enum_type));}
     66                void  SetValue(int integer){_error_("DoubleVec param of enum %i (%s) cannot hold an integer",enum_type,EnumToStringx(enum_type));}
     67                void  SetValue(int* intarray,int M){_error_("DoubleVec param of enum %i (%s) cannot hold an int array",enum_type,EnumToStringx(enum_type));}
     68                void  SetValue(double scalar){_error_("DoubleVec param of enum %i (%s) cannot hold a scalar",enum_type,EnumToStringx(enum_type));}
     69                void  SetValue(char* string){_error_("DoubleVec param of enum %i (%s) cannot hold a string",enum_type,EnumToStringx(enum_type));}
     70                void  SetValue(char** stringarray,int M){_error_("DoubleVec param of enum %i (%s) cannot hold a string array",enum_type,EnumToStringx(enum_type));}
    7171                void  SetValue(double* doublearray,int M);
    72                 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));}
    73                 void  SetValue(Vec vec){_error_("DoubleVec param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));}
    74                 void  SetValue(Mat mat){_error_("DoubleVec param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));}
    75                 void  SetValue(FILE* fid){_error_("DoubleVec param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
    76                 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));}
     72                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));}
     73                void  SetValue(Vec vec){_error_("DoubleVec param of enum %i (%s) cannot hold a Vec",enum_type,EnumToStringx(enum_type));}
     74                void  SetValue(Mat mat){_error_("DoubleVec param of enum %i (%s) cannot hold a Mat",enum_type,EnumToStringx(enum_type));}
     75                void  SetValue(FILE* fid){_error_("DoubleVec param of enum %i (%s) cannot hold a FILE",enum_type,EnumToStringx(enum_type));}
     76                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));}
    7777               
    7878                char* GetParameterName(void);

  • issm/trunk/src/c/objects/Params/FileParam.cpp

    r6412 r8224  
    4949
    5050        printf("FileParam:\n");
    51         printf("   enum:  %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     51        printf("   enum:  %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    5252        printf("   value: %p\n",this->value);
    5353}
    … …  
    9696/*FUNCTION FileParam::GetParameterName{{{1*/
    9797char* FileParam::GetParameterName(void){
    98         return  EnumToString(this->enum_type);
     98        return  EnumToStringx(this->enum_type);
    9999}
    100100/*}}}*/

  • issm/trunk/src/c/objects/Params/FileParam.h

    r6412 r8224  
    4949                /*Param vritual function definitions: {{{1*/
    5050                int   EnumType(){return enum_type;}
    51                 void  GetParameterValue(bool* pbool){  _error_("FileParam of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));}
    52                 void  GetParameterValue(int* pinteger){_error_("FileParam of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
    53                 void  GetParameterValue(int** pintarray,int* pM){_error_("FileParam of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
    54                 void  GetParameterValue(double* pdouble){_error_("FileParam of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
    55                 void  GetParameterValue(char** pstring){_error_("FileParam of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));}
    56                 void  GetParameterValue(char*** pstringarray,int* pM){_error_("FileParam of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));}
    57                 void  GetParameterValue(double** pdoublearray,int* pM){_error_("FileParam of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
    58                 void  GetParameterValue(double** pdoublearray,int* pM, int* pN){_error_("FileParam of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
    59                 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));}
    60                 void  GetParameterValue(Vec* pvec){_error_("FileParam of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));}
    61                 void  GetParameterValue(Mat* pmat){_error_("FileParam of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));}
     51                void  GetParameterValue(bool* pbool){  _error_("FileParam of enum %i (%s) cannot return a bool",enum_type,EnumToStringx(enum_type));}
     52                void  GetParameterValue(int* pinteger){_error_("FileParam of enum %i (%s) cannot return a double",enum_type,EnumToStringx(enum_type));}
     53                void  GetParameterValue(int** pintarray,int* pM){_error_("FileParam of enum %i (%s) cannot return a double",enum_type,EnumToStringx(enum_type));}
     54                void  GetParameterValue(double* pdouble){_error_("FileParam of enum %i (%s) cannot return a double",enum_type,EnumToStringx(enum_type));}
     55                void  GetParameterValue(char** pstring){_error_("FileParam of enum %i (%s) cannot return a string",enum_type,EnumToStringx(enum_type));}
     56                void  GetParameterValue(char*** pstringarray,int* pM){_error_("FileParam of enum %i (%s) cannot return a string arrayl",enum_type,EnumToStringx(enum_type));}
     57                void  GetParameterValue(double** pdoublearray,int* pM){_error_("FileParam of enum %i (%s) cannot return a double array",enum_type,EnumToStringx(enum_type));}
     58                void  GetParameterValue(double** pdoublearray,int* pM, int* pN){_error_("FileParam of enum %i (%s) cannot return a double array",enum_type,EnumToStringx(enum_type));}
     59                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));}
     60                void  GetParameterValue(Vec* pvec){_error_("FileParam of enum %i (%s) cannot return a Vec",enum_type,EnumToStringx(enum_type));}
     61                void  GetParameterValue(Mat* pmat){_error_("FileParam of enum %i (%s) cannot return a Mat",enum_type,EnumToStringx(enum_type));}
    6262                void  GetParameterValue(FILE** pfid){*pfid=value;};
    6363
    64                 void  SetValue(bool boolean){_error_("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
    65                 void  SetValue(int integer){_error_("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
    66                 void  SetValue(int* intarray,int M){_error_("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
    67                 void  SetValue(double scalar){_error_("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
    68                 void  SetValue(char* string){_error_("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
    69                 void  SetValue(char** stringarray,int M){_error_("FileParam of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));}
    70                 void  SetValue(double* doublearray,int M){_error_("FileParam of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
    71                 void  SetValue(double* pdoublearray,int M,int N){_error_("FileParam of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
    72                 void  SetValue(Vec vec){_error_("FileParam of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));}
    73                 void  SetValue(Mat mat){_error_("FileParam of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));}
    74                 void  SetValue(FILE* fid){_error_("File param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
    75                 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));}
     64                void  SetValue(bool boolean){_error_("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumToStringx(enum_type));}
     65                void  SetValue(int integer){_error_("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumToStringx(enum_type));}
     66                void  SetValue(int* intarray,int M){_error_("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumToStringx(enum_type));}
     67                void  SetValue(double scalar){_error_("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumToStringx(enum_type));}
     68                void  SetValue(char* string){_error_("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumToStringx(enum_type));}
     69                void  SetValue(char** stringarray,int M){_error_("FileParam of enum %i (%s) cannot hold a string array",enum_type,EnumToStringx(enum_type));}
     70                void  SetValue(double* doublearray,int M){_error_("FileParam of enum %i (%s) cannot hold a double array",enum_type,EnumToStringx(enum_type));}
     71                void  SetValue(double* pdoublearray,int M,int N){_error_("FileParam of enum %i (%s) cannot hold a double array",enum_type,EnumToStringx(enum_type));}
     72                void  SetValue(Vec vec){_error_("FileParam of enum %i (%s) cannot hold a Vec",enum_type,EnumToStringx(enum_type));}
     73                void  SetValue(Mat mat){_error_("FileParam of enum %i (%s) cannot hold a Mat",enum_type,EnumToStringx(enum_type));}
     74                void  SetValue(FILE* fid){_error_("File param of enum %i (%s) cannot hold a FILE",enum_type,EnumToStringx(enum_type));}
     75                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));}
    7676
    7777                char* GetParameterName(void);

  • issm/trunk/src/c/objects/Params/IntParam.cpp

    r5103 r8224  
    4949
    5050        printf("IntParam:\n");
    51         printf("   enum:  %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     51        printf("   enum:  %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    5252        printf("   value: %i\n",this->value);
    5353}
    … …  
    129129/*FUNCTION IntParam::GetParameterName{{{1*/
    130130char* IntParam::GetParameterName(void){
    131         return  EnumToString(this->enum_type);
     131        return  EnumToStringx(this->enum_type);
    132132}
    133133/*}}}*/

  • issm/trunk/src/c/objects/Params/IntParam.h

    r6412 r8224  
    5050                /*Param vritual function definitions: {{{1*/
    5151                int   EnumType(){return enum_type;}
    52                 void  GetParameterValue(bool* pbool){_error_("Int param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));}
     52                void  GetParameterValue(bool* pbool){_error_("Int param of enum %i (%s) cannot return a bool",enum_type,EnumToStringx(enum_type));}
    5353                void  GetParameterValue(int* pinteger){*pinteger=value;}
    54                 void  GetParameterValue(int** pintarray,int* pM){_error_("Int param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));}
    55                 void  GetParameterValue(double* pdouble){_error_("Int param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
    56                 void  GetParameterValue(char** pstring){_error_("Int param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));}
    57                 void  GetParameterValue(char*** pstringarray,int* pM){_error_("Int param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));}
    58                 void  GetParameterValue(double** pdoublearray,int* pM){_error_("Int param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
    59                 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));}
    60                 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));}
    61                 void  GetParameterValue(Vec* pvec){_error_("Int param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));}
    62                 void  GetParameterValue(Mat* pmat){_error_("Int param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));}
    63                 void  GetParameterValue(FILE** pfid){_error_("Int param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));}
     54                void  GetParameterValue(int** pintarray,int* pM){_error_("Int param of enum %i (%s) cannot return an array of integers",enum_type,EnumToStringx(enum_type));}
     55                void  GetParameterValue(double* pdouble){_error_("Int param of enum %i (%s) cannot return a double",enum_type,EnumToStringx(enum_type));}
     56                void  GetParameterValue(char** pstring){_error_("Int param of enum %i (%s) cannot return a string",enum_type,EnumToStringx(enum_type));}
     57                void  GetParameterValue(char*** pstringarray,int* pM){_error_("Int param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToStringx(enum_type));}
     58                void  GetParameterValue(double** pdoublearray,int* pM){_error_("Int param of enum %i (%s) cannot return a double array",enum_type,EnumToStringx(enum_type));}
     59                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));}
     60                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));}
     61                void  GetParameterValue(Vec* pvec){_error_("Int param of enum %i (%s) cannot return a Vec",enum_type,EnumToStringx(enum_type));}
     62                void  GetParameterValue(Mat* pmat){_error_("Int param of enum %i (%s) cannot return a Mat",enum_type,EnumToStringx(enum_type));}
     63                void  GetParameterValue(FILE** pfid){_error_("Int param of enum %i (%s) cannot return a FILE",enum_type,EnumToStringx(enum_type));}
    6464
    6565                void  SetValue(bool boolean){this->value=(int)boolean;}
    6666                void  SetValue(int integer){this->value=integer;}
    67                 void  SetValue(int* intarray,int M){_error_("Int param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));}
     67                void  SetValue(int* intarray,int M){_error_("Int param of enum %i (%s) cannot hold an int array",enum_type,EnumToStringx(enum_type));}
    6868                void  SetValue(double scalar){this->value=(int)scalar;}
    69                 void  SetValue(char* string){_error_("Int param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
    70                 void  SetValue(char** stringarray,int M){_error_("Int param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));}
    71                 void  SetValue(double* doublearray,int M){_error_("Int param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
    72                 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));}
    73                 void  SetValue(Vec vec){_error_("Int param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));}
    74                 void  SetValue(Mat mat){_error_("Int param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));}
    75                 void  SetValue(FILE* fid){_error_("Int param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
    76                 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));}
     69                void  SetValue(char* string){_error_("Int param of enum %i (%s) cannot hold a string",enum_type,EnumToStringx(enum_type));}
     70                void  SetValue(char** stringarray,int M){_error_("Int param of enum %i (%s) cannot hold a string array",enum_type,EnumToStringx(enum_type));}
     71                void  SetValue(double* doublearray,int M){_error_("Int param of enum %i (%s) cannot hold a double array",enum_type,EnumToStringx(enum_type));}
     72                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));}
     73                void  SetValue(Vec vec){_error_("Int param of enum %i (%s) cannot hold a Vec",enum_type,EnumToStringx(enum_type));}
     74                void  SetValue(Mat mat){_error_("Int param of enum %i (%s) cannot hold a Mat",enum_type,EnumToStringx(enum_type));}
     75                void  SetValue(FILE* fid){_error_("Int param of enum %i (%s) cannot hold a FILE",enum_type,EnumToStringx(enum_type));}
     76                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));}
    7777
    7878                char* GetParameterName(void);

  • issm/trunk/src/c/objects/Params/IntVecParam.cpp

    r6213 r8224  
    5858
    5959        printf("IntVecParam:\n");
    60         printf("   enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     60        printf("   enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    6161        printf("   vector size: %i\n",this->M);
    6262
    … …  
    6969       
    7070        printf("IntVecParam:\n");
    71         printf("   enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     71        printf("   enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    7272        printf("   vector size: %i\n",this->M);
    7373        for(i=0;i<this->M;i++){
    … …  
    170170/*FUNCTION IntVecParam::GetParameterName{{{1*/
    171171char* IntVecParam::GetParameterName(void){
    172         return  EnumToString(this->enum_type);
     172        return  EnumToStringx(this->enum_type);
    173173}
    174174/*}}}*/

  • issm/trunk/src/c/objects/Params/IntVecParam.h

    r6412 r8224  
    5151                /*Param virtual functions definitions: {{{1*/
    5252                int   EnumType(){return enum_type;}
    53                 void  GetParameterValue(bool* pbool){_error_("IntVec param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));}
    54                 void  GetParameterValue(int* pinteger){_error_("IntVec param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));}
     53                void  GetParameterValue(bool* pbool){_error_("IntVec param of enum %i (%s) cannot return a bool",enum_type,EnumToStringx(enum_type));}
     54                void  GetParameterValue(int* pinteger){_error_("IntVec param of enum %i (%s) cannot return an integer",enum_type,EnumToStringx(enum_type));}
    5555                void  GetParameterValue(int** pintarray,int* pM);
    56                 void  GetParameterValue(double* pdouble){_error_("IntVec param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
    57                 void  GetParameterValue(char** pstring){_error_("IntVec param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));}
    58                 void  GetParameterValue(char*** pstringarray,int* pM){_error_("IntVec param of enum %i (%s) cannot return a string array",enum_type,EnumToString(enum_type));}
    59                 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));}
    60                 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));}
    61                 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));}
    62                 void  GetParameterValue(Vec* pvec){_error_("IntVec param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));}
    63                 void  GetParameterValue(Mat* pmat){_error_("IntVec param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));}
    64                 void  GetParameterValue(FILE** pfid){_error_("IntVec param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));}
     56                void  GetParameterValue(double* pdouble){_error_("IntVec param of enum %i (%s) cannot return a double",enum_type,EnumToStringx(enum_type));}
     57                void  GetParameterValue(char** pstring){_error_("IntVec param of enum %i (%s) cannot return a string",enum_type,EnumToStringx(enum_type));}
     58                void  GetParameterValue(char*** pstringarray,int* pM){_error_("IntVec param of enum %i (%s) cannot return a string array",enum_type,EnumToStringx(enum_type));}
     59                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));}
     60                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));}
     61                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));}
     62                void  GetParameterValue(Vec* pvec){_error_("IntVec param of enum %i (%s) cannot return a Vec",enum_type,EnumToStringx(enum_type));}
     63                void  GetParameterValue(Mat* pmat){_error_("IntVec param of enum %i (%s) cannot return a Mat",enum_type,EnumToStringx(enum_type));}
     64                void  GetParameterValue(FILE** pfid){_error_("IntVec param of enum %i (%s) cannot return a FILE",enum_type,EnumToStringx(enum_type));}
    6565
    66                 void  SetValue(bool boolean){_error_("IntVec param of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));}
    67                 void  SetValue(int integer){_error_("IntVec param of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));}
     66                void  SetValue(bool boolean){_error_("IntVec param of enum %i (%s) cannot hold a boolean",enum_type,EnumToStringx(enum_type));}
     67                void  SetValue(int integer){_error_("IntVec param of enum %i (%s) cannot hold an integer",enum_type,EnumToStringx(enum_type));}
    6868                void  SetValue(int* intarray,int M);
    69                 void  SetValue(double scalar){_error_("IntVec param of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));}
    70                 void  SetValue(char* string){_error_("IntVec param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
    71                 void  SetValue(char** stringarray,int M){_error_("IntVec param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));}
    72                 void  SetValue(double* doublearray,int M){_error_("IntVec param of enum %i (%s) cannot hold a double mat array",enum_type,EnumToString(enum_type));}
    73                 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));}
    74                 void  SetValue(Vec vec){_error_("IntVec param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));}
    75                 void  SetValue(Mat mat){_error_("IntVec param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));}
    76                 void  SetValue(FILE* fid){_error_("IntVec param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
    77                 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));}
     69                void  SetValue(double scalar){_error_("IntVec param of enum %i (%s) cannot hold a scalar",enum_type,EnumToStringx(enum_type));}
     70                void  SetValue(char* string){_error_("IntVec param of enum %i (%s) cannot hold a string",enum_type,EnumToStringx(enum_type));}
     71                void  SetValue(char** stringarray,int M){_error_("IntVec param of enum %i (%s) cannot hold a string array",enum_type,EnumToStringx(enum_type));}
     72                void  SetValue(double* doublearray,int M){_error_("IntVec param of enum %i (%s) cannot hold a double mat array",enum_type,EnumToStringx(enum_type));}
     73                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));}
     74                void  SetValue(Vec vec){_error_("IntVec param of enum %i (%s) cannot hold a Vec",enum_type,EnumToStringx(enum_type));}
     75                void  SetValue(Mat mat){_error_("IntVec param of enum %i (%s) cannot hold a Mat",enum_type,EnumToStringx(enum_type));}
     76                void  SetValue(FILE* fid){_error_("IntVec param of enum %i (%s) cannot hold a FILE",enum_type,EnumToStringx(enum_type));}
     77                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));}
    7878               
    7979                char* GetParameterName(void);

  • issm/trunk/src/c/objects/Params/PetscMatParam.cpp

    r5895 r8224  
    4949
    5050        printf("PetscMatParam:\n");
    51         printf("   enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     51        printf("   enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    5252
    5353}
    … …  
    5858        int i;
    5959        printf("PetscMatParam:\n");
    60         printf("   enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     60        printf("   enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    6161        MatView(value,PETSC_VIEWER_STDOUT_WORLD);
    6262}
    … …  
    200200/*FUNCTION PetscMatParam::GetParameterName{{{1*/
    201201char* PetscMatParam::GetParameterName(void){
    202         return  EnumToString(this->enum_type);
     202        return  EnumToStringx(this->enum_type);
    203203}
    204204/*}}}*/

  • issm/trunk/src/c/objects/Params/PetscMatParam.h

    r6412 r8224  
    5050                /*Param vritual function definitions: {{{1*/
    5151                int   EnumType(){return enum_type;}
    52                 void  GetParameterValue(bool* pbool){_error_("PetscMat param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));}
    53                 void  GetParameterValue(int* pinteger){_error_("PetscMat param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));}
    54                 void  GetParameterValue(int** pintarray,int* pM){_error_("PetscMat param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));}
    55                 void  GetParameterValue(double* pdouble){_error_("PetscMat param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
    56                 void  GetParameterValue(char** pstring){_error_("PetscMat param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));}
    57                 void  GetParameterValue(char*** pstringarray,int* pM){_error_("PetscMat param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));}
    58                 void  GetParameterValue(double** pdoublearray,int* pM){_error_("PetscMat param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
    59                 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));}
    60                 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));}
    61                 void  GetParameterValue(Vec* pvec){_error_("PetscMat param of enum %i (%s) cannot return a vec",enum_type,EnumToString(enum_type));}
     52                void  GetParameterValue(bool* pbool){_error_("PetscMat param of enum %i (%s) cannot return a bool",enum_type,EnumToStringx(enum_type));}
     53                void  GetParameterValue(int* pinteger){_error_("PetscMat param of enum %i (%s) cannot return an integer",enum_type,EnumToStringx(enum_type));}
     54                void  GetParameterValue(int** pintarray,int* pM){_error_("PetscMat param of enum %i (%s) cannot return an array of integers",enum_type,EnumToStringx(enum_type));}
     55                void  GetParameterValue(double* pdouble){_error_("PetscMat param of enum %i (%s) cannot return a double",enum_type,EnumToStringx(enum_type));}
     56                void  GetParameterValue(char** pstring){_error_("PetscMat param of enum %i (%s) cannot return a string",enum_type,EnumToStringx(enum_type));}
     57                void  GetParameterValue(char*** pstringarray,int* pM){_error_("PetscMat param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToStringx(enum_type));}
     58                void  GetParameterValue(double** pdoublearray,int* pM){_error_("PetscMat param of enum %i (%s) cannot return a double array",enum_type,EnumToStringx(enum_type));}
     59                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));}
     60                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));}
     61                void  GetParameterValue(Vec* pvec){_error_("PetscMat param of enum %i (%s) cannot return a vec",enum_type,EnumToStringx(enum_type));}
    6262                void  GetParameterValue(Mat* poutput);
    63                 void  GetParameterValue(FILE** pfid){_error_("PetscMat param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));}
     63                void  GetParameterValue(FILE** pfid){_error_("PetscMat param of enum %i (%s) cannot return a FILE",enum_type,EnumToStringx(enum_type));}
    6464
    65                 void  SetValue(bool boolean){_error_("PetscMat param of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));}
    66                 void  SetValue(int integer){_error_("PetscMat param of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));}
    67                 void  SetValue(int* intarray,int M){_error_("PetscMat param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));}
    68                 void  SetValue(double scalar){_error_("PetscMat param of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));}
    69                 void  SetValue(char* string){_error_("PetscMat param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
    70                 void  SetValue(char** stringarray,int M){_error_("PetscMat param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));}
    71                 void  SetValue(double* doublearray,int M){_error_("PetscMat param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
    72                 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));}
    73                 void  SetValue(Vec vec){_error_("PetscMat param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));}
     65                void  SetValue(bool boolean){_error_("PetscMat param of enum %i (%s) cannot hold a boolean",enum_type,EnumToStringx(enum_type));}
     66                void  SetValue(int integer){_error_("PetscMat param of enum %i (%s) cannot hold an integer",enum_type,EnumToStringx(enum_type));}
     67                void  SetValue(int* intarray,int M){_error_("PetscMat param of enum %i (%s) cannot hold an int array",enum_type,EnumToStringx(enum_type));}
     68                void  SetValue(double scalar){_error_("PetscMat param of enum %i (%s) cannot hold a scalar",enum_type,EnumToStringx(enum_type));}
     69                void  SetValue(char* string){_error_("PetscMat param of enum %i (%s) cannot hold a string",enum_type,EnumToStringx(enum_type));}
     70                void  SetValue(char** stringarray,int M){_error_("PetscMat param of enum %i (%s) cannot hold a string array",enum_type,EnumToStringx(enum_type));}
     71                void  SetValue(double* doublearray,int M){_error_("PetscMat param of enum %i (%s) cannot hold a double array",enum_type,EnumToStringx(enum_type));}
     72                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));}
     73                void  SetValue(Vec vec){_error_("PetscMat param of enum %i (%s) cannot hold a Vec",enum_type,EnumToStringx(enum_type));}
    7474                void  SetValue(Mat mat);
    75                 void  SetValue(FILE* fid){_error_("PetscMat param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
    76                 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));}
     75                void  SetValue(FILE* fid){_error_("PetscMat param of enum %i (%s) cannot hold a FILE",enum_type,EnumToStringx(enum_type));}
     76                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));}
    7777
    7878                char* GetParameterName(void);

  • issm/trunk/src/c/objects/Params/PetscVecParam.cpp

    r5103 r8224  
    5050
    5151        printf("PetscVecParam:\n");
    52         printf("   enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     52        printf("   enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    5353
    5454}
    … …  
    5959        int i;
    6060        printf("PetscVecParam:\n");
    61         printf("   enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     61        printf("   enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    6262        VecView(value,PETSC_VIEWER_STDOUT_WORLD);
    6363}
    … …  
    193193/*FUNCTION PetscVecParam::GetParameterName{{{1*/
    194194char* PetscVecParam::GetParameterName(void){
    195         return  EnumToString(this->enum_type);
     195        return  EnumToStringx(this->enum_type);
    196196}
    197197/*}}}*/

  • issm/trunk/src/c/objects/Params/PetscVecParam.h

    r6412 r8224  
    5050                /*Param vritual function definitions: {{{1*/
    5151                int   EnumType(){return enum_type;}
    52                 void  GetParameterValue(bool* pbool){_error_("PetscVec param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));}
    53                 void  GetParameterValue(int* pinteger){_error_("PetscVec param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));}
    54                 void  GetParameterValue(int** pintarray,int* pM){_error_("PetscVec param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));}
    55                 void  GetParameterValue(double* pdouble){_error_("PetscVec param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
    56                 void  GetParameterValue(char** pstring){_error_("PetscVec param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));}
    57                 void  GetParameterValue(char*** pstringarray,int* pM){_error_("PetscVec param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));}
    58                 void  GetParameterValue(double** pdoublearray,int* pM){_error_("PetscVec param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
    59                 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));}
    60                 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));}
    61                 void  GetParameterValue(Mat* pmat){_error_("PetscVec param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));}
     52                void  GetParameterValue(bool* pbool){_error_("PetscVec param of enum %i (%s) cannot return a bool",enum_type,EnumToStringx(enum_type));}
     53                void  GetParameterValue(int* pinteger){_error_("PetscVec param of enum %i (%s) cannot return an integer",enum_type,EnumToStringx(enum_type));}
     54                void  GetParameterValue(int** pintarray,int* pM){_error_("PetscVec param of enum %i (%s) cannot return an array of integers",enum_type,EnumToStringx(enum_type));}
     55                void  GetParameterValue(double* pdouble){_error_("PetscVec param of enum %i (%s) cannot return a double",enum_type,EnumToStringx(enum_type));}
     56                void  GetParameterValue(char** pstring){_error_("PetscVec param of enum %i (%s) cannot return a string",enum_type,EnumToStringx(enum_type));}
     57                void  GetParameterValue(char*** pstringarray,int* pM){_error_("PetscVec param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToStringx(enum_type));}
     58                void  GetParameterValue(double** pdoublearray,int* pM){_error_("PetscVec param of enum %i (%s) cannot return a double array",enum_type,EnumToStringx(enum_type));}
     59                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));}
     60                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));}
     61                void  GetParameterValue(Mat* pmat){_error_("PetscVec param of enum %i (%s) cannot return a Mat",enum_type,EnumToStringx(enum_type));}
    6262                void  GetParameterValue(Vec* poutput);
    63                 void  GetParameterValue(FILE** pfid){_error_("PetscVec of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));}
     63                void  GetParameterValue(FILE** pfid){_error_("PetscVec of enum %i (%s) cannot return a FILE",enum_type,EnumToStringx(enum_type));}
    6464
    65                 void  SetValue(bool boolean){_error_("PetscVec of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));}
    66                 void  SetValue(int integer){_error_("PetscVec of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));}
    67                 void  SetValue(int* intarray,int M){_error_("PetscVec of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));}
    68                 void  SetValue(double scalar){_error_("PetscVec of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));}
    69                 void  SetValue(char* string){_error_("PetscVec of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
    70                 void  SetValue(char** stringarray,int M){_error_("PetscVec of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));}
    71                 void  SetValue(double* doublearray,int M){_error_("PetscVec of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
    72                 void  SetValue(double* pdoublearray,int M,int N){_error_("PetscVec of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
     65                void  SetValue(bool boolean){_error_("PetscVec of enum %i (%s) cannot hold a boolean",enum_type,EnumToStringx(enum_type));}
     66                void  SetValue(int integer){_error_("PetscVec of enum %i (%s) cannot hold an integer",enum_type,EnumToStringx(enum_type));}
     67                void  SetValue(int* intarray,int M){_error_("PetscVec of enum %i (%s) cannot hold an int array",enum_type,EnumToStringx(enum_type));}
     68                void  SetValue(double scalar){_error_("PetscVec of enum %i (%s) cannot hold a scalar",enum_type,EnumToStringx(enum_type));}
     69                void  SetValue(char* string){_error_("PetscVec of enum %i (%s) cannot hold a string",enum_type,EnumToStringx(enum_type));}
     70                void  SetValue(char** stringarray,int M){_error_("PetscVec of enum %i (%s) cannot hold a string array",enum_type,EnumToStringx(enum_type));}
     71                void  SetValue(double* doublearray,int M){_error_("PetscVec of enum %i (%s) cannot hold a double array",enum_type,EnumToStringx(enum_type));}
     72                void  SetValue(double* pdoublearray,int M,int N){_error_("PetscVec of enum %i (%s) cannot hold a double array",enum_type,EnumToStringx(enum_type));}
    7373                void  SetValue(Vec vec);
    74                 void  SetValue(Mat mat){_error_("PetscVec of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));}
    75                 void  SetValue(FILE* fid){_error_("PetscVec of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
    76                 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));}
     74                void  SetValue(Mat mat){_error_("PetscVec of enum %i (%s) cannot hold a Mat",enum_type,EnumToStringx(enum_type));}
     75                void  SetValue(FILE* fid){_error_("PetscVec of enum %i (%s) cannot hold a FILE",enum_type,EnumToStringx(enum_type));}
     76                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));}
    7777
    7878                char* GetParameterName(void);

  • issm/trunk/src/c/objects/Params/StringArrayParam.cpp

    r5103 r8224  
    7373
    7474        printf("StringArrayParam:\n");
    75         printf("   enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     75        printf("   enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    7676        for(i=0;i<this->numstrings;i++){
    7777                string=this->value[i];
    … …  
    222222/*FUNCTION StringArrayParam::GetParameterName{{{1*/
    223223char* StringArrayParam::GetParameterName(void){
    224         return  EnumToString(this->enum_type);
     224        return  EnumToStringx(this->enum_type);
    225225}
    226226/*}}}*/

  • issm/trunk/src/c/objects/Params/StringArrayParam.h

    r6412 r8224  
    5252                /*Param vritual function definitions: {{{1*/
    5353                int   EnumType(){return enum_type;}
    54                 void  GetParameterValue(bool* pbool){_error_("StringArray param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));}
    55                 void  GetParameterValue(int* pinteger){_error_("StringArray param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));}
    56                 void  GetParameterValue(int** pintarray,int* pM){_error_("StringArray param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));}
    57                 void  GetParameterValue(double* pdouble){_error_("StringArray param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
    58                 void  GetParameterValue(char** pstring){_error_("StringArray param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));}
     54                void  GetParameterValue(bool* pbool){_error_("StringArray param of enum %i (%s) cannot return a bool",enum_type,EnumToStringx(enum_type));}
     55                void  GetParameterValue(int* pinteger){_error_("StringArray param of enum %i (%s) cannot return an integer",enum_type,EnumToStringx(enum_type));}
     56                void  GetParameterValue(int** pintarray,int* pM){_error_("StringArray param of enum %i (%s) cannot return an array of integers",enum_type,EnumToStringx(enum_type));}
     57                void  GetParameterValue(double* pdouble){_error_("StringArray param of enum %i (%s) cannot return a double",enum_type,EnumToStringx(enum_type));}
     58                void  GetParameterValue(char** pstring){_error_("StringArray param of enum %i (%s) cannot return a string",enum_type,EnumToStringx(enum_type));}
    5959                void  GetParameterValue(char*** pstringarray,int* pM);
    60                 void  GetParameterValue(double** pdoublearray,int* pM){_error_("StringArray param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
    61                 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));}
    62                 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));}
    63                 void  GetParameterValue(Vec* pvec){_error_("StringArray param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));}
    64                 void  GetParameterValue(Mat* pmat){_error_("StringArray param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));}
    65                 void  GetParameterValue(FILE** pfid){_error_("StringArray param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));}
     60                void  GetParameterValue(double** pdoublearray,int* pM){_error_("StringArray param of enum %i (%s) cannot return a double array",enum_type,EnumToStringx(enum_type));}
     61                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));}
     62                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));}
     63                void  GetParameterValue(Vec* pvec){_error_("StringArray param of enum %i (%s) cannot return a Vec",enum_type,EnumToStringx(enum_type));}
     64                void  GetParameterValue(Mat* pmat){_error_("StringArray param of enum %i (%s) cannot return a Mat",enum_type,EnumToStringx(enum_type));}
     65                void  GetParameterValue(FILE** pfid){_error_("StringArray param of enum %i (%s) cannot return a FILE",enum_type,EnumToStringx(enum_type));}
    6666
    67                 void  SetValue(bool boolean){_error_("StringArray param of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));}
    68                 void  SetValue(int integer){_error_("StringArray param of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));}
    69                 void  SetValue(int* intarray,int M){_error_("StringArray param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));}
    70                 void  SetValue(double scalar){_error_("StringArray param of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));}
    71                 void  SetValue(char* string){_error_("StringArray param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
     67                void  SetValue(bool boolean){_error_("StringArray param of enum %i (%s) cannot hold a boolean",enum_type,EnumToStringx(enum_type));}
     68                void  SetValue(int integer){_error_("StringArray param of enum %i (%s) cannot hold an integer",enum_type,EnumToStringx(enum_type));}
     69                void  SetValue(int* intarray,int M){_error_("StringArray param of enum %i (%s) cannot hold an int array",enum_type,EnumToStringx(enum_type));}
     70                void  SetValue(double scalar){_error_("StringArray param of enum %i (%s) cannot hold a scalar",enum_type,EnumToStringx(enum_type));}
     71                void  SetValue(char* string){_error_("StringArray param of enum %i (%s) cannot hold a string",enum_type,EnumToStringx(enum_type));}
    7272                void  SetValue(char** stringarray,int M);
    73                 void  SetValue(double* doublearray,int M){_error_("StringArray param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
    74                 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));}
    75                 void  SetValue(Vec vec){_error_("StringArray param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));}
    76                 void  SetValue(Mat mat){_error_("StringArray param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));}
    77                 void  SetValue(FILE* fid){_error_("StringArray param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
    78                 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));}
     73                void  SetValue(double* doublearray,int M){_error_("StringArray param of enum %i (%s) cannot hold a double array",enum_type,EnumToStringx(enum_type));}
     74                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));}
     75                void  SetValue(Vec vec){_error_("StringArray param of enum %i (%s) cannot hold a Vec",enum_type,EnumToStringx(enum_type));}
     76                void  SetValue(Mat mat){_error_("StringArray param of enum %i (%s) cannot hold a Mat",enum_type,EnumToStringx(enum_type));}
     77                void  SetValue(FILE* fid){_error_("StringArray param of enum %i (%s) cannot hold a FILE",enum_type,EnumToStringx(enum_type));}
     78                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));}
    7979
    8080                char* GetParameterName(void);

  • issm/trunk/src/c/objects/Params/StringParam.cpp

    r5103 r8224  
    5050void StringParam::DeepEcho(void){
    5151        printf("StringParam:\n");
    52         printf("   enum:  %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
     52        printf("   enum:  %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
    5353        printf("   value: %s\n",this->value);
    5454}
    … …  
    158158/*FUNCTION StringParam::GetParameterName{{{1*/
    159159char* StringParam::GetParameterName(void){
    160         return  EnumToString(this->enum_type);
     160        return  EnumToStringx(this->enum_type);
    161161}
    162162/*}}}*/

  • issm/trunk/src/c/objects/Params/StringParam.h

    r6412 r8224  
    5050                /*Param vritual function definitions: {{{1*/
    5151                int   EnumType(){return enum_type;}
    52                 void  GetParameterValue(bool* pbool){_error_("String param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));}
    53                 void  GetParameterValue(int* pinteger){_error_("String param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));}
    54                 void  GetParameterValue(int** pintarray,int* pM){_error_("String param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));}
    55                 void  GetParameterValue(double* pdouble){_error_("String param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
     52                void  GetParameterValue(bool* pbool){_error_("String param of enum %i (%s) cannot return a bool",enum_type,EnumToStringx(enum_type));}
     53                void  GetParameterValue(int* pinteger){_error_("String param of enum %i (%s) cannot return an integer",enum_type,EnumToStringx(enum_type));}
     54                void  GetParameterValue(int** pintarray,int* pM){_error_("String param of enum %i (%s) cannot return an array of integers",enum_type,EnumToStringx(enum_type));}
     55                void  GetParameterValue(double* pdouble){_error_("String param of enum %i (%s) cannot return a double",enum_type,EnumToStringx(enum_type));}
    5656                void  GetParameterValue(char** pstring);
    57                 void  GetParameterValue(char*** pstringarray,int* pM){_error_("String param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));}
    58                 void  GetParameterValue(double** pdoublearray,int* pM){_error_("String param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
    59                 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));}
    60                 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));}
    61                 void  GetParameterValue(Vec* pvec){_error_("String param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));}
    62                 void  GetParameterValue(Mat* pmat){_error_("String param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));}
    63                 void  GetParameterValue(FILE** pfid){_error_("Bool param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));}
     57                void  GetParameterValue(char*** pstringarray,int* pM){_error_("String param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToStringx(enum_type));}
     58                void  GetParameterValue(double** pdoublearray,int* pM){_error_("String param of enum %i (%s) cannot return a double array",enum_type,EnumToStringx(enum_type));}
     59                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));}
     60                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));}
     61                void  GetParameterValue(Vec* pvec){_error_("String param of enum %i (%s) cannot return a Vec",enum_type,EnumToStringx(enum_type));}
     62                void  GetParameterValue(Mat* pmat){_error_("String param of enum %i (%s) cannot return a Mat",enum_type,EnumToStringx(enum_type));}
     63                void  GetParameterValue(FILE** pfid){_error_("Bool param of enum %i (%s) cannot return a FILE",enum_type,EnumToStringx(enum_type));}
    6464
    65                 void  SetValue(bool boolean){_error_("String param of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));}
    66                 void  SetValue(int integer){_error_("String param of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));}
    67                 void  SetValue(int* intarray,int M){_error_("String param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));}
    68                 void  SetValue(double scalar){_error_("String param of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));}
     65                void  SetValue(bool boolean){_error_("String param of enum %i (%s) cannot hold a boolean",enum_type,EnumToStringx(enum_type));}
     66                void  SetValue(int integer){_error_("String param of enum %i (%s) cannot hold an integer",enum_type,EnumToStringx(enum_type));}
     67                void  SetValue(int* intarray,int M){_error_("String param of enum %i (%s) cannot hold an int array",enum_type,EnumToStringx(enum_type));}
     68                void  SetValue(double scalar){_error_("String param of enum %i (%s) cannot hold a scalar",enum_type,EnumToStringx(enum_type));}
    6969                void  SetValue(char* string);
    70                 void  SetValue(char** stringarray,int M){_error_("String param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));}
    71                 void  SetValue(double* doublearray,int M){_error_("String param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
    72                 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));}
    73                 void  SetValue(Vec vec){_error_("String param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));}
    74                 void  SetValue(Mat mat){_error_("String param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));}
    75                 void  SetValue(FILE* fid){_error_("String param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
    76                 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));}
     70                void  SetValue(char** stringarray,int M){_error_("String param of enum %i (%s) cannot hold a string array",enum_type,EnumToStringx(enum_type));}
     71                void  SetValue(double* doublearray,int M){_error_("String param of enum %i (%s) cannot hold a double array",enum_type,EnumToStringx(enum_type));}
     72                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));}
     73                void  SetValue(Vec vec){_error_("String param of enum %i (%s) cannot hold a Vec",enum_type,EnumToStringx(enum_type));}
     74                void  SetValue(Mat mat){_error_("String param of enum %i (%s) cannot hold a Mat",enum_type,EnumToStringx(enum_type));}
     75                void  SetValue(FILE* fid){_error_("String param of enum %i (%s) cannot hold a FILE",enum_type,EnumToStringx(enum_type));}
     76                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));}
    7777
    7878                char* GetParameterName(void);

  • issm/trunk/src/c/shared/Numerics/IsInputConverged.cpp

    r6412 r8224  
    5353                else eps=0;
    5454        }
    55         else _error_("%s%s%s"," convergence criterion ",EnumToString(criterion_enum)," not supported yet!");
     55        else _error_("%s%s%s"," convergence criterion ",EnumToStringx(criterion_enum)," not supported yet!");
    5656
    5757        /*Assign output pointers:*/

  • issm/trunk/src/c/shared/Numerics/PetscOptionsFromAnalysis.cpp

    r6852 r8224  
    5757        if (found==-1){
    5858                /*ok, we did not find anything, this is not good! error out: */
    59                 _error_("%s%s","could find neither a default analysis  nor analysis ",EnumToString(analysis_type));
     59                _error_("%s%s","could find neither a default analysis  nor analysis ",EnumToStringx(analysis_type));
    6060        }
    6161

  • issm/trunk/src/c/shared/Numerics/extrema.cpp

    r1 r8224  
    1111
    1212double min(double a,double b){
    13         if (a<=b)return a;
     13        if (a<b)return a;
     14        else return b;
     15}
     16int min(int a,int b){
     17        if (a<b)return a;
    1418        else return b;
    1519}
    1620double max(double a,double b){
    17         if (a>=b)return a;
     21        if (a>b)return a;
    1822        else return b;
    1923}
     24int max(int a,int b){
     25        if (a>b)return a;
     26        else return b;
     27}

  • issm/trunk/src/c/shared/Numerics/numerics.h

    r6273 r8224  
    1818double min(double a,double b);
    1919double max(double a,double b);
     20int    min(int a,int b);
     21int    max(int a,int b);
    2022double OptFunc(double scalar, OptArgs* optargs);
    2123void   BrentSearch(double* psearch_scalar,double* pJ,OptPars* optpars,double (*f)(double,OptArgs*), OptArgs* optargs);

  • issm/trunk/src/c/solutions/AdjointCorePointerFromSolutionEnum.cpp

    r6412 r8224  
    3535                        break;
    3636                default:
    37                         _error_("No adjoint has been implemented for solution %s yet",EnumToString(solutiontype));
     37                        _error_("No adjoint has been implemented for solution %s yet",EnumToStringx(solutiontype));
    3838                        break;
    3939        }

  • issm/trunk/src/c/solutions/CorePointerFromSolutionEnum.cpp

    r7640 r8224  
    6262                        break;
    6363                default:
    64                         _error_("%s%s%s"," solution type: ",EnumToString(solutiontype)," not supported yet!");
     64                        _error_("%s%s%s"," solution type: ",EnumToStringx(solutiontype)," not supported yet!");
    6565                        break;
    6666        }

  • issm/trunk/src/c/solutions/SolutionConfiguration.cpp

    r7640 r8224  
    131131
    132132                default:
    133                         _error_("%s%s%s"," solution type: ",EnumToString(solutiontype)," not supported yet!");
     133                        _error_("%s%s%s"," solution type: ",EnumToStringx(solutiontype)," not supported yet!");
    134134                        break;
    135135        }

  • issm/trunk/src/c/solutions/control_core.cpp

    r7288 r8224  
    122122                for(i=0;i<num_controls;i++) InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,control_type[i]);
    123123                femmodel->results->AddObject(new DoubleVecExternalResult(femmodel->results->Size()+1,JEnum,J,nsteps,1,0));
    124                 //femmodel->results->AddObject(new StringExternalResult(femmodel->results->Size()+1,ControlTypeEnum,EnumToString(control_type),1,0));
     124                //femmodel->results->AddObject(new StringExternalResult(femmodel->results->Size()+1,ControlTypeEnum,EnumToStringx(control_type),1,0));
    125125        }
    126126

  • issm/trunk/src/c/solutions/controlrestart.cpp

    r6213 r8224  
    2626                for(int i=0;i<num_controls;i++) InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,control_type[i]);
    2727                femmodel->results->AddObject(new DoubleVecExternalResult(femmodel->results->Size()+1,JEnum,J,nsteps,1,0));
    28                 //femmodel->results->AddObject(new StringExternalResult(femmodel->results->Size()+1,ControlTypeEnum,EnumToString(control_type),1,0));
     28                //femmodel->results->AddObject(new StringExternalResult(femmodel->results->Size()+1,ControlTypeEnum,EnumToStringx(control_type),1,0));
    2929
    3030                /*write to disk: */

  • issm/trunk/src/c/solutions/gradient_core.cpp

    r6412 r8224  
    3636        for (int i=0;i<num_controls;i++){
    3737
    38                 _printf_(VerboseControl(),"   compute gradient of J with respect to %s\n",EnumToString(control_type[i]));
     38                _printf_(VerboseControl(),"   compute gradient of J with respect to %s\n",EnumToStringx(control_type[i]));
    3939                Gradjx(&gradient, femmodel->elements,femmodel->nodes, femmodel->vertices,femmodel->loads, femmodel->materials,femmodel->parameters, control_type[i]);
    4040
    … …  
    5353                /*Get scaling factor of current control:*/
    5454                VecNorm(new_gradient,NORM_INFINITY,&norm_grad);
    55                 if(norm_grad<=0)    _error_("||∂J/∂α||∞ = 0    gradient norm of J with respect to %s is zero",EnumToString(control_type[i]));
    56                 if(isnan(norm_grad))_error_("||∂J/∂α||∞ = NaN  gradient norm of J with respect to %s is NaN" ,EnumToString(control_type[i]));
     55                if(norm_grad<=0)    _error_("||∂J/∂α||∞ = 0    gradient norm of J with respect to %s is zero",EnumToStringx(control_type[i]));
     56                if(isnan(norm_grad))_error_("||∂J/∂α||∞ = NaN  gradient norm of J with respect to %s is NaN" ,EnumToStringx(control_type[i]));
    5757                if(i==0 || (optscal_list[num_controls*step+i]/norm_grad)<optscal) optscal=optscal_list[num_controls*step+i]/norm_grad;
    5858

  • issm/trunk/src/c/solutions/issm.cpp

    r8196 r8224  
    5151        _printf_(true,"Launching solution sequence\n");
    5252        if(argc<2)_error_("Usage error: no solution requested");
    53         solution_type=StringToEnum(argv[1]);
     53        solution_type=StringToEnumx(argv[1]);
    5454        petscoptionsfilename=argv[4];
    5555        lockname=argv[6];

  • issm/trunk/src/c/solutions/objectivefunctionC.cpp

    r7638 r8224  
    5555        }
    5656        else{
    57                 _error_("Solution %s not implemented yet",EnumToString(solution_type));
     57                _error_("Solution %s not implemented yet",EnumToStringx(solution_type));
    5858        }
    5959
    … …  
    7272        }
    7373        else{
    74                 _error_("Solution %s not implemented yet",EnumToString(solution_type));
     74                _error_("Solution %s not implemented yet",EnumToStringx(solution_type));
    7575        }
    7676
Note: See TracChangeset for help on using the changeset viewer.