Changeset 20635


Ignore:
Timestamp:
05/23/16 09:16:41 (9 years ago)
Author:
Mathieu Morlighem
Message:

CHG: replaced Parameters by a static array

Location:
issm/trunk-jpl/src/c
Files:
43 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/c/classes/FemModel.cpp

    r20618 r20635  
    8080        /*Save communicator in the parameters dataset: */
    8181        this->parameters->AddObject(new GenericParam<ISSM_MPI_Comm>(incomm,FemModelCommEnum));
    82 
    8382
    8483        /*Free resources */

  • issm/trunk-jpl/src/c/classes/IoModel.cpp

    r19138 r20635  
    281281
    282282        /*Find constant*/
    283         Param* param=xDynamicCast<Param*>(this->constants->FindParamObject(constant_enum));
     283        //FIXME _error_("Needs to be FIXED");
     284        Param* param=this->constants->FindParamObject(constant_enum);
    284285        if(!param) _error_("Constant " << EnumToStringx(constant_enum) << " not found in iomodel");
    285286
    … …  
    485486
    486487                                                /*create BoolParam: */
    487                                                 this->constants->AddObject(new BoolParam(record_enum,(bool)booleanint)); //cast to boolean
     488                                                if(record_enum!=MaximumNumberOfDefinitionsEnum && record_enum!=MaximumNumberOfDefinitionsEnum+1)
     489                                                 this->constants->AddObject(new BoolParam(record_enum,(bool)booleanint)); //cast to boolean
    488490
    489491                                                break;
    … …  
    594596
    595597                                        /*create BoolParam: */
    596                                         this->constants->AddObject(new BoolParam(record_enum,(bool)booleanint)); //cast to a boolean
     598                                        if(record_enum!=MaximumNumberOfDefinitionsEnum && record_enum!=MaximumNumberOfDefinitionsEnum+1)
     599                                         this->constants->AddObject(new BoolParam(record_enum,(bool)booleanint)); //cast to a boolean
    597600                                        break;
    598601

  • issm/trunk-jpl/src/c/classes/Params/BoolParam.cpp

    r19254 r20635  
    4848}
    4949/*}}}*/
    50 Object* BoolParam::copy() {/*{{{*/
     50Param* BoolParam::copy() {/*{{{*/
    5151
    5252        return new BoolParam(this->enum_type,this->value);

  • issm/trunk-jpl/src/c/classes/Params/BoolParam.h

    r19216 r20635  
    3535                int   Id();
    3636                int   ObjectEnum();
    37                 Object* copy();
     37                Param* copy();
    3838                void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    3939                /*}}}*/

  • issm/trunk-jpl/src/c/classes/Params/DataSetParam.cpp

    r19217 r20635  
    5252}
    5353/*}}}*/
    54 Object* DataSetParam::copy() {/*{{{*/
     54Param* DataSetParam::copy() {/*{{{*/
    5555
    5656        return new DataSetParam(this->enum_type,this->value);

  • issm/trunk-jpl/src/c/classes/Params/DataSetParam.h

    r19217 r20635  
    3636                int   Id();
    3737                int   ObjectEnum();
    38                 Object* copy();
     38                Param* copy();
    3939                void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    4040                /*}}}*/

  • issm/trunk-jpl/src/c/classes/Params/DoubleMatArrayParam.cpp

    r19254 r20635  
    116116}
    117117/*}}}*/
    118 Object* DoubleMatArrayParam::copy() {/*{{{*/
     118Param* DoubleMatArrayParam::copy() {/*{{{*/
    119119
    120120        return new DoubleMatArrayParam(this->enum_type,this->array, this->M, this->mdim_array,this->ndim_array);

  • issm/trunk-jpl/src/c/classes/Params/DoubleMatArrayParam.h

    r19222 r20635  
    3838                int   Id();
    3939                int   ObjectEnum();
    40                 Object* copy();
     40                Param* copy();
    4141                void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    4242                /*}}}*/

  • issm/trunk-jpl/src/c/classes/Params/DoubleMatParam.cpp

    r20026 r20635  
    6767}
    6868/*}}}*/
    69 Object* DoubleMatParam::copy() {/*{{{*/
     69Param* DoubleMatParam::copy() {/*{{{*/
    7070
    7171        return new DoubleMatParam(this->enum_type,this->value,this->M,this->N);

  • issm/trunk-jpl/src/c/classes/Params/DoubleMatParam.h

    r20026 r20635  
    3737                int   Id();
    3838                int   ObjectEnum();
    39                 Object* copy();
     39                Param* copy();
    4040                void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    4141                /*}}}*/

  • issm/trunk-jpl/src/c/classes/Params/DoubleParam.cpp

    r19215 r20635  
    4646}
    4747/*}}}*/
    48 Object* DoubleParam::copy() {/*{{{*/
     48Param* DoubleParam::copy() {/*{{{*/
    4949
    5050        return new DoubleParam(this->enum_type,this->value);

  • issm/trunk-jpl/src/c/classes/Params/DoubleParam.h

    r19215 r20635  
    3636                int   Id();
    3737                int   ObjectEnum();
    38                 Object* copy();
     38                Param* copy();
    3939                void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    4040                /*}}}*/

  • issm/trunk-jpl/src/c/classes/Params/DoubleVecParam.cpp

    r20028 r20635  
    5959}
    6060/*}}}*/
    61 Object* DoubleVecParam::copy() {/*{{{*/
     61Param* DoubleVecParam::copy() {/*{{{*/
    6262
    6363        return new DoubleVecParam(this->enum_type,this->values,this->M);

  • issm/trunk-jpl/src/c/classes/Params/DoubleVecParam.h

    r20028 r20635  
    3636                int   Id();
    3737                int   ObjectEnum();
    38                 Object* copy();
     38                Param* copy();
    3939                void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    4040                /*}}}*/

  • issm/trunk-jpl/src/c/classes/Params/FileParam.cpp

    r19261 r20635  
    4949}
    5050/*}}}*/
    51 Object* FileParam::copy() {/*{{{*/
     51Param* FileParam::copy() {/*{{{*/
    5252
    5353        return new FileParam(this->enum_type,this->value);

  • issm/trunk-jpl/src/c/classes/Params/FileParam.h

    r19222 r20635  
    3535                int   Id();
    3636                int   ObjectEnum();
    37                 Object* copy();
     37                Param* copy();
    3838                void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    3939                /*}}}*/

  • issm/trunk-jpl/src/c/classes/Params/GenericParam.h

    r20365 r20635  
    5252                // it does not clarify  ownership of the newed up instance...
    5353                // use the default copy constructor instead
    54                 Object* copy() { return new GenericParam<P>(*this); };
     54                Param* copy() { return new GenericParam<P>(*this); };
    5555                                         void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){
    5656                                                 _printf_("   WARNING: parameter "<<EnumToStringx(this->myEnumVal)<<" is a GenericParam and cannot be marshalled\n");

  • issm/trunk-jpl/src/c/classes/Params/IntMatParam.cpp

    r19254 r20635  
    6767}
    6868/*}}}*/
    69 Object* IntMatParam::copy() {/*{{{*/
     69Param* IntMatParam::copy() {/*{{{*/
    7070
    7171        return new IntMatParam(this->enum_type,this->value,this->M,this->N);

  • issm/trunk-jpl/src/c/classes/Params/IntMatParam.h

    r19222 r20635  
    3737                int   Id();
    3838                int   ObjectEnum();
    39                 Object* copy();
     39                Param* copy();
    4040                void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    4141                /*}}}*/

  • issm/trunk-jpl/src/c/classes/Params/IntParam.cpp

    r19254 r20635  
    4949}
    5050/*}}}*/
    51 Object* IntParam::copy() {/*{{{*/
     51Param* IntParam::copy() {/*{{{*/
    5252
    5353        return new IntParam(this->enum_type,this->value);

  • issm/trunk-jpl/src/c/classes/Params/IntParam.h

    r19215 r20635  
    3636                int   Id();
    3737                int   ObjectEnum();
    38                 Object* copy();
     38                Param* copy();
    3939                void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    4040                /*}}}*/

  • issm/trunk-jpl/src/c/classes/Params/IntVecParam.cpp

    r19254 r20635  
    7979}
    8080/*}}}*/
    81 Object* IntVecParam::copy() {/*{{{*/
     81Param* IntVecParam::copy() {/*{{{*/
    8282
    8383        return new IntVecParam(this->enum_type,this->values,this->M);

  • issm/trunk-jpl/src/c/classes/Params/IntVecParam.h

    r19222 r20635  
    3737                int   Id();
    3838                int   ObjectEnum();
    39                 Object* copy();
     39                Param* copy();
    4040                void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    4141                /*}}}*/

  • issm/trunk-jpl/src/c/classes/Params/MatrixParam.cpp

    r19254 r20635  
    5858}
    5959/*}}}*/
    60 Object* MatrixParam::copy() {/*{{{*/
     60Param* MatrixParam::copy() {/*{{{*/
    6161
    6262        return new MatrixParam(this->enum_type,this->value);

  • issm/trunk-jpl/src/c/classes/Params/MatrixParam.h

    r19198 r20635  
    3636                int   Id();
    3737                int   ObjectEnum();
    38                 Object* copy();
     38                Param* copy();
    3939                void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!"); };
    4040                /*}}}*/

  • issm/trunk-jpl/src/c/classes/Params/Param.h

    r16233 r20635  
    1919/*}}}*/
    2020
    21 class Param: public Object{
     21class Param{
    2222
    2323        public:
    … …  
    2525
    2626                /*Virtual functions:*/
     27                virtual void  Echo()=0;
     28                virtual Param* copy()=0;
    2729                virtual int   InstanceEnum()=0;
    2830                virtual void  GetParameterValue(bool* pbool)=0;

  • issm/trunk-jpl/src/c/classes/Params/Parameters.cpp

    r20553 r20635  
    4141/*Object constructors and destructor*/
    4242Parameters::Parameters(){/*{{{*/
    43         enum_type=ParametersEnum;
     43        for(int i=0;i<NUMPARAMS;i++) this->params[i] = NULL;
    4444        return;
    4545}
    4646/*}}}*/
    4747Parameters::~Parameters(){/*{{{*/
     48        for(int i=0;i<NUMPARAMS;i++){
     49                if(this->params[i]) delete this->params[i];
     50        }
    4851        return;
    4952}
    5053/*}}}*/
    5154
     55void Parameters::AddObject(Param* newparam){/*{{{*/
     56
     57        /*Get Enum from Param*/
     58        _assert_(newparam);
     59        int param_enum = newparam->InstanceEnum();
     60
     61        /*Get index in array*/
     62        _assert_(param_enum>ParametersSTARTEnum);
     63        _assert_(param_enum<ParametersENDEnum);
     64        int index = param_enum - ParametersSTARTEnum -1;
     65
     66        /*Delete param if it already exists*/
     67        if(this->params[index]){
     68                delete this->params[index];
     69                this->params[index] = NULL;
     70        }
     71
     72        /*Add param to array*/
     73        this->params[index] = newparam;
     74}
     75/*}}}*/
     76Parameters* Parameters::Copy(void){/*{{{*/
     77        _error_("not implemented yet");
     78}
     79/*}}}*/
     80void Parameters::Marshall(char** pmarshalled_data, int* pmarshalled_data_size, int marshall_direction){/*{{{*/
     81        _error_("not implemented yet");
     82}
     83/*}}}*/
     84void Parameters::Echo(void){/*{{{*/
     85        _error_("not implemented yet");
     86}
     87/*}}}*/
     88void Parameters::DeepEcho(void){/*{{{*/
     89        _error_("not implemented yet");
     90}
     91/*}}}*/
     92
    5293/*Object management*/
    53 bool Parameters::Exist(int enum_type){/*{{{*/
    54 
    55         vector<Object*>::iterator object;
    56         Param* param=NULL;
    57 
    58         for ( object=objects.begin() ; object < objects.end(); object++ ){
    59                 param=xDynamicCast<Param*>(*object);
    60                 if(param->InstanceEnum()==enum_type) return true;
    61         }
     94bool Parameters::Exist(int param_enum){/*{{{*/
     95
     96        _assert_(param_enum>ParametersSTARTEnum);
     97        _assert_(param_enum<ParametersENDEnum);
     98
     99        int index = param_enum - ParametersSTARTEnum -1;
     100        if(this->params[index]) return true;
     101
    62102        return false;
    63103}
    64104/*}}}*/
    65 void Parameters::FindParam(bool* pbool,int enum_type){ _assert_(this);/*{{{*/
    66 
    67         vector<Object*>::iterator object;
    68         Param* param=NULL;
    69 
    70         for ( object=objects.begin() ; object < objects.end(); object++ ){
    71 
    72                 param=xDynamicCast<Param*>(*object);
    73                 if(param->InstanceEnum()==enum_type){
    74                         param->GetParameterValue(pbool);
    75                         return;
    76                 }
    77         }
    78         _error_("could not find parameter " << EnumToStringx(enum_type));
    79 }
    80 /*}}}*/
    81 void Parameters::FindParam(int* pinteger,int enum_type){ _assert_(this);/*{{{*/
    82 
    83         vector<Object*>::iterator object;
    84         Param* param=NULL;
    85 
    86         for ( object=objects.begin() ; object < objects.end(); object++ ){
    87 
    88                 param=xDynamicCast<Param*>(*object);
    89                 if(param->InstanceEnum()==enum_type){
    90                         param->GetParameterValue(pinteger);
    91                         return;
    92                 }
    93         }
    94         _error_("could not find parameter " << EnumToStringx(enum_type));
    95 }
    96 /*}}}*/
    97 void Parameters::FindParam(IssmDouble* pscalar, int enum_type){ _assert_(this);/*{{{*/
    98 
    99         vector<Object*>::iterator object;
    100         Param* param=NULL;
    101 
    102         for ( object=objects.begin() ; object < objects.end(); object++ ){
    103 
    104                 param=xDynamicCast<Param*>(*object);
    105                 if(param->InstanceEnum()==enum_type){
    106                         param->GetParameterValue(pscalar);
    107                         return;
    108                 }
    109         }
    110         _error_("could not find parameter " <<  EnumToStringx(enum_type));
    111 }
    112 /*}}}*/
    113 void Parameters::FindParam(IssmDouble* pscalar, int enum_type,IssmDouble time){ _assert_(this);/*{{{*/
    114 
    115         vector<Object*>::iterator object;
    116         Param* param=NULL;
    117 
    118         for ( object=objects.begin() ; object < objects.end(); object++ ){
    119 
    120                 param=xDynamicCast<Param*>(*object);
    121                 if(param->InstanceEnum()==enum_type){
    122                         param->GetParameterValue(pscalar,time);
    123                         return;
    124                 }
    125         }
    126         _error_("could not find parameter " << EnumToStringx(enum_type));
    127 }
    128 /*}}}*/
    129 void Parameters::FindParam(char** pstring,int enum_type){ _assert_(this);/*{{{*/
    130 
    131         vector<Object*>::iterator object;
    132         Param* param=NULL;
    133 
    134         for ( object=objects.begin() ; object < objects.end(); object++ ){
    135 
    136                 param=xDynamicCast<Param*>(*object);
    137                 if(param->InstanceEnum()==enum_type){
    138                         param->GetParameterValue(pstring);
    139                         return;
    140                 }
    141         }
    142         _error_("could not find parameter " << EnumToStringx(enum_type));
    143 
    144 }
    145 /*}}}*/
    146 void Parameters::FindParam(char*** pstringarray,int* pM,int enum_type){ _assert_(this);/*{{{*/
    147 
    148         vector<Object*>::iterator object;
    149         Param* param=NULL;
    150 
    151         for ( object=objects.begin() ; object < objects.end(); object++ ){
    152 
    153                 param=xDynamicCast<Param*>(*object);
    154                 if(param->InstanceEnum()==enum_type){
    155                         param->GetParameterValue(pstringarray,pM);
    156                         return;
    157                 }
    158         }
    159         _error_("could not find parameter " << EnumToStringx(enum_type));
    160 
    161 }
    162 /*}}}*/
    163 void Parameters::FindParam(int** pintarray,int* pM, int enum_type){ _assert_(this);/*{{{*/
    164 
    165         vector<Object*>::iterator object;
    166         Param* param=NULL;
    167 
    168         for ( object=objects.begin() ; object < objects.end(); object++ ){
    169 
    170                 param=xDynamicCast<Param*>(*object);
    171                 if(param->InstanceEnum()==enum_type){
    172                         param->GetParameterValue(pintarray,pM);
    173                         return;
    174                 }
    175         }
    176         _error_("could not find parameter " << EnumToStringx(enum_type));
    177 
    178 }
    179 /*}}}*/
    180 void Parameters::FindParam(int** pintarray,int* pM,int *pN,int enum_type){ _assert_(this);/*{{{*/
    181 
    182         vector<Object*>::iterator object;
    183         Param* param=NULL;
    184 
    185         for ( object=objects.begin() ; object < objects.end(); object++ ){
    186 
    187                 param=xDynamicCast<Param*>(*object);
    188                 if(param->InstanceEnum()==enum_type){
    189                         param->GetParameterValue(pintarray,pM,pN);
    190                         return;
    191                 }
    192         }
    193         _error_("could not find parameter " << EnumToStringx(enum_type));
    194 
    195 }
    196 /*}}}*/
    197 void Parameters::FindParam(IssmDouble** pIssmDoublearray,int* pM, int enum_type){ _assert_(this);/*{{{*/
    198 
    199         vector<Object*>::iterator object;
    200         Param* param=NULL;
    201 
    202         for ( object=objects.begin() ; object < objects.end(); object++ ){
    203 
    204                 param=xDynamicCast<Param*>(*object);
    205                 if(param->InstanceEnum()==enum_type){
    206                         param->GetParameterValue(pIssmDoublearray,pM);
    207                         return;
    208                 }
    209         }
    210         _error_("could not find parameter " << EnumToStringx(enum_type));
    211 
    212 }
    213 /*}}}*/
    214 void Parameters::FindParam(IssmDouble** pIssmDoublearray,int* pM, int* pN,int enum_type){ _assert_(this);/*{{{*/
    215 
    216         vector<Object*>::iterator object;
    217         Param* param=NULL;
    218 
    219         for ( object=objects.begin() ; object < objects.end(); object++ ){
    220 
    221                 param=xDynamicCast<Param*>(*object);
    222                 if(param->InstanceEnum()==enum_type){
    223                         param->GetParameterValue(pIssmDoublearray,pM,pN);
    224                         return;
    225                 }
    226         }
    227         _error_("could not find parameter " << EnumToStringx(enum_type));
    228 
    229 }
    230 /*}}}*/
    231 void Parameters::FindParam(IssmDouble*** parray,int* pM,int** pmdims_array,int** pndims_array,int enum_type){ _assert_(this);/*{{{*/
    232 
    233         vector<Object*>::iterator object;
    234         Param* param=NULL;
    235 
    236         for ( object=objects.begin() ; object < objects.end(); object++ ){
    237 
    238                 param=xDynamicCast<Param*>(*object);
    239                 if(param->InstanceEnum()==enum_type){
    240                         param->GetParameterValue(parray,pM,pmdims_array,pndims_array);
    241                         return;
    242                 }
    243         }
    244         _error_("could not find parameter " << EnumToStringx(enum_type));
    245 }
    246 /*}}}*/
    247 void Parameters::FindParam(Vector<IssmDouble>** pvec,int enum_type){ _assert_(this);/*{{{*/
    248 
    249         vector<Object*>::iterator object;
    250         Param* param=NULL;
    251 
    252         for ( object=objects.begin() ; object < objects.end(); object++ ){
    253 
    254                 param=xDynamicCast<Param*>(*object);
    255                 if(param->InstanceEnum()==enum_type){
    256                         param->GetParameterValue(pvec);
    257                         return;
    258                 }
    259         }
    260         _error_("could not find parameter " << EnumToStringx(enum_type));
    261 
    262 }
    263 /*}}}*/
    264 void Parameters::FindParam(Matrix<IssmDouble>** pmat,int enum_type){ _assert_(this);/*{{{*/
    265 
    266         vector<Object*>::iterator object;
    267         Param* param=NULL;
    268 
    269         for ( object=objects.begin() ; object < objects.end(); object++ ){
    270 
    271                 param=xDynamicCast<Param*>(*object);
    272                 if(param->InstanceEnum()==enum_type){
    273                         param->GetParameterValue(pmat);
    274                         return;
    275                 }
    276         }
    277         _error_("could not find parameter " << EnumToStringx(enum_type));
    278 
    279 }
    280 /*}}}*/
    281 void Parameters::FindParam(FILE** pfid,int enum_type){ _assert_(this);/*{{{*/
    282 
    283         vector<Object*>::iterator object;
    284         Param* param=NULL;
    285 
    286         for ( object=objects.begin() ; object < objects.end(); object++ ){
    287 
    288                 param=xDynamicCast<Param*>(*object);
    289                 if(param->InstanceEnum()==enum_type){
    290                         param->GetParameterValue(pfid);
    291                         return;
    292                 }
    293         }
    294         _error_("could not find parameter " << EnumToStringx(enum_type));
    295 }
    296 /*}}}*/
    297 void Parameters::FindParam(DataSet** pdataset,int enum_type){ /*{{{*/
     105void Parameters::FindParam(bool* pbool,int param_enum){ _assert_(this);/*{{{*/
     106
     107        _assert_(param_enum>ParametersSTARTEnum);
     108        _assert_(param_enum<ParametersENDEnum);
     109
     110        int index = param_enum - ParametersSTARTEnum -1;
     111        if(!this->params[index]) _error_("Parameter " << EnumToStringx(param_enum) <<" not set");
     112        this->params[index]->GetParameterValue(pbool);
     113}
     114/*}}}*/
     115void Parameters::FindParam(int* pinteger,int param_enum){ _assert_(this);/*{{{*/
     116
     117        _assert_(param_enum>ParametersSTARTEnum);
     118        _assert_(param_enum<ParametersENDEnum);
     119
     120        int index = param_enum - ParametersSTARTEnum -1;
     121        if(!this->params[index]) _error_("Parameter " << EnumToStringx(param_enum) <<" not set");
     122        this->params[index]->GetParameterValue(pinteger);
     123}
     124/*}}}*/
     125void Parameters::FindParam(IssmDouble* pscalar,int param_enum){ _assert_(this);/*{{{*/
     126
     127        _assert_(param_enum>ParametersSTARTEnum);
     128        _assert_(param_enum<ParametersENDEnum);
     129
     130        int index = param_enum - ParametersSTARTEnum -1;
     131        if(!this->params[index]) _error_("Parameter " << EnumToStringx(param_enum) <<" not set");
     132        this->params[index]->GetParameterValue(pscalar);
     133}
     134/*}}}*/
     135void Parameters::FindParam(IssmDouble* pscalar, int param_enum,IssmDouble time){ _assert_(this);/*{{{*/
     136
     137        _assert_(param_enum>ParametersSTARTEnum);
     138        _assert_(param_enum<ParametersENDEnum);
     139
     140        int index = param_enum - ParametersSTARTEnum -1;
     141        if(!this->params[index]) _error_("Parameter " << EnumToStringx(param_enum) <<" not set");
     142        this->params[index]->GetParameterValue(pscalar,time);
     143}
     144/*}}}*/
     145void Parameters::FindParam(char** pstring,int param_enum){ _assert_(this);/*{{{*/
     146
     147        _assert_(param_enum>ParametersSTARTEnum);
     148        _assert_(param_enum<ParametersENDEnum);
     149
     150        int index = param_enum - ParametersSTARTEnum -1;
     151        if(!this->params[index]) _error_("Parameter " << EnumToStringx(param_enum) <<" not set");
     152        this->params[index]->GetParameterValue(pstring);
     153
     154}
     155/*}}}*/
     156void Parameters::FindParam(char*** pstringarray,int* pM,int param_enum){ _assert_(this);/*{{{*/
     157
     158        _assert_(param_enum>ParametersSTARTEnum);
     159        _assert_(param_enum<ParametersENDEnum);
     160
     161        int index = param_enum - ParametersSTARTEnum -1;
     162        if(!this->params[index]) _error_("Parameter " << EnumToStringx(param_enum) <<" not set");
     163        this->params[index]->GetParameterValue(pstringarray,pM);
     164}
     165/*}}}*/
     166void Parameters::FindParam(int** pintarray,int* pM, int param_enum){ _assert_(this);/*{{{*/
     167
     168        _assert_(param_enum>ParametersSTARTEnum);
     169        _assert_(param_enum<ParametersENDEnum);
     170
     171        int index = param_enum - ParametersSTARTEnum -1;
     172        if(!this->params[index]) _error_("Parameter " << EnumToStringx(param_enum) <<" not set");
     173        this->params[index]->GetParameterValue(pintarray,pM);
     174
     175}
     176/*}}}*/
     177void Parameters::FindParam(int** pintarray,int* pM,int *pN,int param_enum){ _assert_(this);/*{{{*/
     178
     179        _assert_(param_enum>ParametersSTARTEnum);
     180        _assert_(param_enum<ParametersENDEnum);
     181
     182        int index = param_enum - ParametersSTARTEnum -1;
     183        if(!this->params[index]) _error_("Parameter " << EnumToStringx(param_enum) <<" not set");
     184        this->params[index]->GetParameterValue(pintarray,pM,pN);
     185
     186}
     187/*}}}*/
     188void Parameters::FindParam(IssmDouble** pIssmDoublearray,int* pM, int param_enum){ _assert_(this);/*{{{*/
     189
     190        _assert_(param_enum>ParametersSTARTEnum);
     191        _assert_(param_enum<ParametersENDEnum);
     192
     193        int index = param_enum - ParametersSTARTEnum -1;
     194        if(!this->params[index]) _error_("Parameter " << EnumToStringx(param_enum) <<" not set");
     195        this->params[index]->GetParameterValue(pIssmDoublearray,pM);
     196}
     197/*}}}*/
     198void Parameters::FindParam(IssmDouble** pIssmDoublearray,int* pM, int* pN,int param_enum){ _assert_(this);/*{{{*/
     199
     200        _assert_(param_enum>ParametersSTARTEnum);
     201        _assert_(param_enum<ParametersENDEnum);
     202
     203        int index = param_enum - ParametersSTARTEnum -1;
     204        if(!this->params[index]) _error_("Parameter " << EnumToStringx(param_enum) <<" not set");
     205        this->params[index]->GetParameterValue(pIssmDoublearray,pM,pN);
     206}
     207/*}}}*/
     208void Parameters::FindParam(IssmDouble*** parray,int* pM,int** pmdims_array,int** pndims_array,int param_enum){ _assert_(this);/*{{{*/
     209
     210        _assert_(param_enum>ParametersSTARTEnum);
     211        _assert_(param_enum<ParametersENDEnum);
     212
     213        int index = param_enum - ParametersSTARTEnum -1;
     214        if(!this->params[index]) _error_("Parameter " << EnumToStringx(param_enum) <<" not set");
     215        this->params[index]->GetParameterValue(parray,pM,pmdims_array,pndims_array);
     216}
     217/*}}}*/
     218void Parameters::FindParam(Vector<IssmDouble>** pvec,int param_enum){ _assert_(this);/*{{{*/
     219
     220        _assert_(param_enum>ParametersSTARTEnum);
     221        _assert_(param_enum<ParametersENDEnum);
     222
     223        int index = param_enum - ParametersSTARTEnum -1;
     224        if(!this->params[index]) _error_("Parameter " << EnumToStringx(param_enum) <<" not set");
     225        this->params[index]->GetParameterValue(pvec);
     226}
     227/*}}}*/
     228void Parameters::FindParam(Matrix<IssmDouble>** pmat,int param_enum){ _assert_(this);/*{{{*/
     229
     230        _assert_(param_enum>ParametersSTARTEnum);
     231        _assert_(param_enum<ParametersENDEnum);
     232
     233        int index = param_enum - ParametersSTARTEnum -1;
     234        if(!this->params[index]) _error_("Parameter " << EnumToStringx(param_enum) <<" not set");
     235        this->params[index]->GetParameterValue(pmat);
     236}
     237/*}}}*/
     238void Parameters::FindParam(FILE** pfid,int param_enum){ _assert_(this);/*{{{*/
     239
     240        _assert_(param_enum>ParametersSTARTEnum);
     241        _assert_(param_enum<ParametersENDEnum);
     242
     243        int index = param_enum - ParametersSTARTEnum -1;
     244        if(!this->params[index]) _error_("Parameter " << EnumToStringx(param_enum) <<" not set");
     245        this->params[index]->GetParameterValue(pfid);
     246}
     247/*}}}*/
     248void Parameters::FindParam(DataSet** pdataset,int param_enum){ /*{{{*/
    298249        _assert_(this);
    299250
    300         vector<Object*>::iterator object;
    301         Param* param=NULL;
    302 
    303         for ( object=objects.begin() ; object < objects.end(); object++ ){
    304 
    305                 param=xDynamicCast<Param*>(*object);
    306                 if(param->InstanceEnum()==enum_type){
    307                         param->GetParameterValue(pdataset);
    308                         return;
    309                 }
    310         }
    311         _error_("could not find parameter " << EnumToStringx(enum_type));
     251        _assert_(param_enum>ParametersSTARTEnum);
     252        _assert_(param_enum<ParametersENDEnum);
     253
     254        int index = param_enum - ParametersSTARTEnum -1;
     255        if(!this->params[index]) _error_("Parameter " << EnumToStringx(param_enum) <<" not set");
     256        this->params[index]->GetParameterValue(pdataset);
    312257}
    313258/*}}}*/
    … …  
    457402/*}}}*/
    458403
    459 Object* Parameters::FindParamObject(int enum_type){/*{{{*/
    460 
    461         vector<Object*>::iterator object;
    462         Param* param=NULL;
    463 
    464         for ( object=objects.begin() ; object < objects.end(); object++ ){
    465 
    466                 param=xDynamicCast<Param*>(*object);
    467                 if(param && param->InstanceEnum()==enum_type){
    468                         return (*object);
    469                 }
    470         }
    471         return NULL;
     404Param* Parameters::FindParamObject(int param_enum){/*{{{*/
     405
     406        _assert_(param_enum>ParametersSTARTEnum);
     407        _assert_(param_enum<ParametersENDEnum);
     408
     409        int index = param_enum - ParametersSTARTEnum -1;
     410        return this->params[index];
    472411}
    473412/*}}}*/

  • issm/trunk-jpl/src/c/classes/Params/Parameters.h

    r16792 r20635  
    44
    55/*forward declarations */
     6class Param;
     7class DataSet;
    68template <class doublematrix> class Matrix;
    79template <class doubletype> class Vector;
    8 #include "../../datastructures/datastructures.h"
    910#include "../../shared/shared.h"
     11
     12#define NUMPARAMS ParametersENDEnum - ParametersSTARTEnum -1
    1013
    1114/*!\brief Declaration of Parameters class. 
    1215 *
    13  * Declaration of Parameters class.  Parameters are vector lists (Containers) of Parameter objects.
     16 * Declaration of Parameters class.  Parameters are a static array of Parameter objects.
    1417 */
    15 class Parameters: public DataSet{
     18class Parameters{
     19
     20        private:
     21                Param* params[NUMPARAMS];
    1622
    1723        public:
    … …  
    2329                /*numerics*/
    2430                bool  Exist(int enum_type);
     31                void  AddObject(Param* newparam);
     32                Parameters* Copy(void);
     33                void  Marshall(char** pmarshalled_data, int* pmarshalled_data_size, int marshall_direction);
     34                void  Echo();
     35                void  DeepEcho();
    2536
    2637                void  FindParam(bool* pinteger,int enum_type);
    … …  
    5465                void  SetParam(DataSet* dataset,int enum_type);
    5566
    56                 Object* FindParamObject(int enum_type);
     67                Param* FindParamObject(int enum_type);
    5768
    5869};
    5970
    6071/*Methods relating to parameters: */
    61 char       *OptionsFromAnalysis(Parameters *parameters,int analysis_type);
    62 void        ToolkitsOptionsFromAnalysis(Parameters* parameters,int analysis_type);
     72char *OptionsFromAnalysis(Parameters *parameters,int analysis_type);
     73void  ToolkitsOptionsFromAnalysis(Parameters* parameters,int analysis_type);
    6374
    6475#endif //ifndef _PARAMETERS_H_

  • issm/trunk-jpl/src/c/classes/Params/StringArrayParam.cpp

    r19254 r20635  
    7575}
    7676/*}}}*/
    77 Object* StringArrayParam::copy() {/*{{{*/
     77Param* StringArrayParam::copy() {/*{{{*/
    7878
    7979        return new StringArrayParam(this->enum_type,this->value,this->numstrings);

  • issm/trunk-jpl/src/c/classes/Params/StringArrayParam.h

    r19217 r20635  
    3636                int   Id();
    3737                int   ObjectEnum();
    38                 Object* copy();
     38                Param* copy();
    3939                void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    4040                /*}}}*/

  • issm/trunk-jpl/src/c/classes/Params/StringParam.cpp

    r19254 r20635  
    5050}
    5151/*}}}*/
    52 Object* StringParam::copy() {/*{{{*/
     52Param* StringParam::copy() {/*{{{*/
    5353
    5454        return new StringParam(this->enum_type,this->value);

  • issm/trunk-jpl/src/c/classes/Params/StringParam.h

    r19222 r20635  
    3636                int   Id();
    3737                int   ObjectEnum();
    38                 Object* copy();
     38                Param* copy();
    3939                void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    4040                /*}}}*/

  • issm/trunk-jpl/src/c/classes/Params/TransientParam.cpp

    r19254 r20635  
    6868}
    6969/*}}}*/
    70 Object* TransientParam::copy() {/*{{{*/
     70Param* TransientParam::copy() {/*{{{*/
    7171
    7272        return new TransientParam(this->enum_type,this->values,this->timesteps,this->interpolation,this->N);

  • issm/trunk-jpl/src/c/classes/Params/TransientParam.h

    r19254 r20635  
    3838                int   Id();
    3939                int   ObjectEnum();
    40                 Object* copy();
     40                Param* copy();
    4141                void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
    4242                /*}}}*/

  • issm/trunk-jpl/src/c/classes/Params/VectorParam.cpp

    r18064 r20635  
    6060}
    6161/*}}}*/
    62 Object* VectorParam::copy() {/*{{{*/
     62Param* VectorParam::copy() {/*{{{*/
    6363
    6464        return new VectorParam(this->enum_type,this->value);

  • issm/trunk-jpl/src/c/classes/Params/VectorParam.h

    r19198 r20635  
    3636                int   Id();
    3737                int   ObjectEnum();
    38                 Object* copy();
     38                Param* copy();
    3939                void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){ _error_("not implemented yet!"); };
    4040                /*}}}*/

  • issm/trunk-jpl/src/c/classes/Profiler.h

    r19215 r20635  
    1616
    1717enum ProfilerEnums {
    18         Start,
     18        Start=ParametersSTARTEnum+1,//FIXME
    1919        StartInit,
    2020        FinishInit,

  • issm/trunk-jpl/src/c/datastructures/DataSet.cpp

    r20362 r20635  
    161161                                this->AddObject(vertex);
    162162                        }
    163                         else if(obj_enum==DoubleParamEnum){
    164                                 DoubleParam* doubleparam=NULL;
    165                                 doubleparam=new DoubleParam();
    166                                 doubleparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    167                                 this->AddObject(doubleparam);
    168                         }
    169                         else if(obj_enum==IntParamEnum){
    170                                 IntParam* intparam=NULL;
    171                                 intparam=new IntParam();
    172                                 intparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    173                                 this->AddObject(intparam);
    174                         }
    175                         else if(obj_enum==IntMatParamEnum){
    176                                 IntMatParam* intmparam=NULL;
    177                                 intmparam=new IntMatParam();
    178                                 intmparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    179                                 this->AddObject(intmparam);
    180                         }
    181                         else if(obj_enum==IntVecParamEnum){
    182                                 IntVecParam* intvparam=NULL;
    183                                 intvparam=new IntVecParam();
    184                                 intvparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    185                                 this->AddObject(intvparam);
    186                         }
    187                         else if(obj_enum==BoolParamEnum){
    188                                 BoolParam* boolparam=NULL;
    189                                 boolparam=new BoolParam();
    190                                 boolparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    191                                 this->AddObject(boolparam);
    192                         }
    193                         else if(obj_enum==DataSetParamEnum){
    194                                 DataSetParam* dsparam=NULL;
    195                                 dsparam=new DataSetParam();
    196                                 dsparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    197                                 this->AddObject(dsparam);
    198                         }
    199                         else if(obj_enum==DoubleMatArrayParamEnum){
    200                                 DoubleMatArrayParam* dmaparam=NULL;
    201                                 dmaparam=new DoubleMatArrayParam();
    202                                 dmaparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    203                                 this->AddObject(dmaparam);
    204                         }
    205                         else if(obj_enum==DoubleMatParamEnum){
    206                                 DoubleMatParam* dmparam=NULL;
    207                                 dmparam=new DoubleMatParam();
    208                                 dmparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    209                                 this->AddObject(dmparam);
    210                         }
    211                         else if(obj_enum==DoubleVecParamEnum){
    212                                 DoubleVecParam* dvparam=NULL;
    213                                 dvparam=new DoubleVecParam();
    214                                 dvparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    215                                 this->AddObject(dvparam);
    216                         }
    217                         else if(obj_enum==FileParamEnum){
    218                                 FileParam* fileparam=NULL;
    219                                 fileparam=new FileParam();
    220                                 fileparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    221                                 delete fileparam;
    222                                 /* No need to add this object, the pointer is not valid             
    223                                    The FemModel should reset all FileParams in the restart function */
    224                         }
    225                         else if(obj_enum==StringParamEnum){
    226                                 StringParam* sparam=NULL;
    227                                 sparam=new StringParam();
    228                                 sparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    229                                 this->AddObject(sparam);
    230                         }
    231                         else if(obj_enum==StringArrayParamEnum){
    232                                 StringArrayParam* saparam=NULL;
    233                                 saparam=new StringArrayParam();
    234                                 saparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    235                                 this->AddObject(saparam);
    236                         }
    237                         else if(obj_enum==TransientParamEnum){
    238                                 TransientParam* transparam=NULL;
    239                                 transparam=new TransientParam();
    240                                 transparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
    241                                 this->AddObject(transparam);
    242                         }
    243                         else if(obj_enum==GenericParamEnum){
    244                                 /*Skip for now (we don't want to Marhsall Comms*/
    245                         }
     163                        //else if(obj_enum==DoubleParamEnum){
     164                        //      DoubleParam* doubleparam=NULL;
     165                        //      doubleparam=new DoubleParam();
     166                        //      doubleparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
     167                        //      this->AddObject(doubleparam);
     168                        //}
     169                        //else if(obj_enum==IntParamEnum){
     170                        //      IntParam* intparam=NULL;
     171                        //      intparam=new IntParam();
     172                        //      intparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
     173                        //      this->AddObject(intparam);
     174                        //}
     175                        //else if(obj_enum==IntMatParamEnum){
     176                        //      IntMatParam* intmparam=NULL;
     177                        //      intmparam=new IntMatParam();
     178                        //      intmparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
     179                        //      this->AddObject(intmparam);
     180                        //}
     181                        //else if(obj_enum==IntVecParamEnum){
     182                        //      IntVecParam* intvparam=NULL;
     183                        //      intvparam=new IntVecParam();
     184                        //      intvparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
     185                        //      this->AddObject(intvparam);
     186                        //}
     187                        //else if(obj_enum==BoolParamEnum){
     188                        //      BoolParam* boolparam=NULL;
     189                        //      boolparam=new BoolParam();
     190                        //      boolparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
     191                        //      this->AddObject(boolparam);
     192                        //}
     193                        //else if(obj_enum==DataSetParamEnum){
     194                        //      DataSetParam* dsparam=NULL;
     195                        //      dsparam=new DataSetParam();
     196                        //      dsparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
     197                        //      this->AddObject(dsparam);
     198                        //}
     199                        //else if(obj_enum==DoubleMatArrayParamEnum){
     200                        //      DoubleMatArrayParam* dmaparam=NULL;
     201                        //      dmaparam=new DoubleMatArrayParam();
     202                        //      dmaparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
     203                        //      this->AddObject(dmaparam);
     204                        //}
     205                        //else if(obj_enum==DoubleMatParamEnum){
     206                        //      DoubleMatParam* dmparam=NULL;
     207                        //      dmparam=new DoubleMatParam();
     208                        //      dmparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
     209                        //      this->AddObject(dmparam);
     210                        //}
     211                        //else if(obj_enum==DoubleVecParamEnum){
     212                        //      DoubleVecParam* dvparam=NULL;
     213                        //      dvparam=new DoubleVecParam();
     214                        //      dvparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
     215                        //      this->AddObject(dvparam);
     216                        //}
     217                        //else if(obj_enum==FileParamEnum){
     218                        //      FileParam* fileparam=NULL;
     219                        //      fileparam=new FileParam();
     220                        //      fileparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
     221                        //      delete fileparam;
     222                        //      /* No need to add this object, the pointer is not valid             
     223                        //         The FemModel should reset all FileParams in the restart function */
     224                        //}
     225                        //else if(obj_enum==StringParamEnum){
     226                        //      StringParam* sparam=NULL;
     227                        //      sparam=new StringParam();
     228                        //      sparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
     229                        //      this->AddObject(sparam);
     230                        //}
     231                        //else if(obj_enum==StringArrayParamEnum){
     232                        //      StringArrayParam* saparam=NULL;
     233                        //      saparam=new StringArrayParam();
     234                        //      saparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
     235                        //      this->AddObject(saparam);
     236                        //}
     237                        //else if(obj_enum==TransientParamEnum){
     238                        //      TransientParam* transparam=NULL;
     239                        //      transparam=new TransientParam();
     240                        //      transparam->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
     241                        //      this->AddObject(transparam);
     242                        //}
     243                        //else if(obj_enum==GenericParamEnum){
     244                        //      /*Skip for now (we don't want to Marhsall Comms*/
     245                        //}
    246246                        else if(obj_enum==MaticeEnum){
    247247                                Matice* matice=NULL;

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateParameters.cpp

    r20459 r20635  
    3939        IssmDouble  yts;
    4040        int         N,M;
    41 
    42         /*Make sure current dataset is empty*/
    43         _assert_(parameters->Size()==0);
    4441
    4542        /*Copy some constants from iomodel */

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

    r19749 r20635  
    9090
    9191        constraints->Presort();
    92         parameters->Presort();
    9392        if(VerboseMProcessor()) _printf0_("   done with model processor \n");
    9493

  • issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h

    r20622 r20635  
    88
    99enum definitions{
     10        ParametersSTARTEnum,
    1011        /*General: {{{*/
    1112        FemModelEnum,
    … …  
    10731074        SealevelriseNumRequestedOutputsEnum,
    10741075        /*}}}*/
     1076        ParametersENDEnum,
    10751077        MaximumNumberOfDefinitionsEnum
    10761078};

  • issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp

    r20622 r20635  
    1717        switch(en){
    1818
     19                case ParametersSTARTEnum : return "ParametersSTART";
    1920                case FemModelEnum : return "FemModel";
    2021                case FemModelCommEnum : return "FemModelComm";
    … …  
    10241025                case SealevelriseRequestedOutputsEnum : return "SealevelriseRequestedOutputs";
    10251026                case SealevelriseNumRequestedOutputsEnum : return "SealevelriseNumRequestedOutputs";
     1027                case ParametersENDEnum : return "ParametersEND";
    10261028                case MaximumNumberOfDefinitionsEnum : return "MaximumNumberOfDefinitions";
    10271029                default : return "unknown";

  • issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp

    r20622 r20635  
    1717
    1818   if(stage==1){
    19               if (strcmp(name,"FemModel")==0) return FemModelEnum;
     19              if (strcmp(name,"ParametersSTART")==0) return ParametersSTARTEnum;
     20              else if (strcmp(name,"FemModel")==0) return FemModelEnum;
    2021              else if (strcmp(name,"FemModelComm")==0) return FemModelCommEnum;
    2122              else if (strcmp(name,"WorldComm")==0) return WorldCommEnum;
    … …  
    136137              else if (strcmp(name,"HydrologyModel")==0) return HydrologyModelEnum;
    137138              else if (strcmp(name,"Hydrologyshreve")==0) return HydrologyshreveEnum;
    138               else if (strcmp(name,"HydrologyshreveSpcwatercolumn")==0) return HydrologyshreveSpcwatercolumnEnum;
    139139         else stage=2;
    140140   }
    141141   if(stage==2){
    142               if (strcmp(name,"HydrologyshreveStabilization")==0) return HydrologyshreveStabilizationEnum;
     142              if (strcmp(name,"HydrologyshreveSpcwatercolumn")==0) return HydrologyshreveSpcwatercolumnEnum;
     143              else if (strcmp(name,"HydrologyshreveStabilization")==0) return HydrologyshreveStabilizationEnum;
    143144              else if (strcmp(name,"Hydrologydc")==0) return HydrologydcEnum;
    144145              else if (strcmp(name,"SedimentHead")==0) return SedimentHeadEnum;
    … …  
    259260              else if (strcmp(name,"DamageEvolutionRequestedOutputs")==0) return DamageEvolutionRequestedOutputsEnum;
    260261              else if (strcmp(name,"Damage")==0) return DamageEnum;
    261               else if (strcmp(name,"NewDamage")==0) return NewDamageEnum;
    262262         else stage=3;
    263263   }
    264264   if(stage==3){
    265               if (strcmp(name,"StressIntensityFactor")==0) return StressIntensityFactorEnum;
     265              if (strcmp(name,"NewDamage")==0) return NewDamageEnum;
     266              else if (strcmp(name,"StressIntensityFactor")==0) return StressIntensityFactorEnum;
    266267              else if (strcmp(name,"CalvingLaw")==0) return CalvingLawEnum;
    267268              else if (strcmp(name,"CalvingCalvingrate")==0) return CalvingCalvingrateEnum;
    … …  
    382383              else if (strcmp(name,"TransientIsmasstransport")==0) return TransientIsmasstransportEnum;
    383384              else if (strcmp(name,"TransientIsthermal")==0) return TransientIsthermalEnum;
    384               else if (strcmp(name,"TransientIsgia")==0) return TransientIsgiaEnum;
    385385         else stage=4;
    386386   }
    387387   if(stage==4){
    388               if (strcmp(name,"TransientIsdamageevolution")==0) return TransientIsdamageevolutionEnum;
     388              if (strcmp(name,"TransientIsgia")==0) return TransientIsgiaEnum;
     389              else if (strcmp(name,"TransientIsdamageevolution")==0) return TransientIsdamageevolutionEnum;
    389390              else if (strcmp(name,"TransientIshydrology")==0) return TransientIshydrologyEnum;
    390391              else if (strcmp(name,"TransientIsmovingfront")==0) return TransientIsmovingfrontEnum;
    … …  
    505506              else if (strcmp(name,"BalancethicknessAnalysis")==0) return BalancethicknessAnalysisEnum;
    506507              else if (strcmp(name,"BalancethicknessSolution")==0) return BalancethicknessSolutionEnum;
    507               else if (strcmp(name,"Balancethickness2Analysis")==0) return Balancethickness2AnalysisEnum;
    508508         else stage=5;
    509509   }
    510510   if(stage==5){
    511               if (strcmp(name,"Balancethickness2Solution")==0) return Balancethickness2SolutionEnum;
     511              if (strcmp(name,"Balancethickness2Analysis")==0) return Balancethickness2AnalysisEnum;
     512              else if (strcmp(name,"Balancethickness2Solution")==0) return Balancethickness2SolutionEnum;
    512513              else if (strcmp(name,"BalancethicknessSoftAnalysis")==0) return BalancethicknessSoftAnalysisEnum;
    513514              else if (strcmp(name,"BalancethicknessSoftSolution")==0) return BalancethicknessSoftSolutionEnum;
    … …  
    628629              else if (strcmp(name,"MassconaxpbyNamey")==0) return MassconaxpbyNameyEnum;
    629630              else if (strcmp(name,"MassconaxpbyAlpha")==0) return MassconaxpbyAlphaEnum;
    630               else if (strcmp(name,"MassconaxpbyBeta")==0) return MassconaxpbyBetaEnum;
    631631         else stage=6;
    632632   }
    633633   if(stage==6){
    634               if (strcmp(name,"NodeSId")==0) return NodeSIdEnum;
     634              if (strcmp(name,"MassconaxpbyBeta")==0) return MassconaxpbyBetaEnum;
     635              else if (strcmp(name,"NodeSId")==0) return NodeSIdEnum;
    635636              else if (strcmp(name,"VectorParam")==0) return VectorParamEnum;
    636637              else if (strcmp(name,"Riftfront")==0) return RiftfrontEnum;
    … …  
    751752              else if (strcmp(name,"StrainRatexy")==0) return StrainRatexyEnum;
    752753              else if (strcmp(name,"StrainRatexz")==0) return StrainRatexzEnum;
    753               else if (strcmp(name,"StrainRateyy")==0) return StrainRateyyEnum;
    754754         else stage=7;
    755755   }
    756756   if(stage==7){
    757               if (strcmp(name,"StrainRateyz")==0) return StrainRateyzEnum;
     757              if (strcmp(name,"StrainRateyy")==0) return StrainRateyyEnum;
     758              else if (strcmp(name,"StrainRateyz")==0) return StrainRateyzEnum;
    758759              else if (strcmp(name,"StrainRatezz")==0) return StrainRatezzEnum;
    759760              else if (strcmp(name,"Divergence")==0) return DivergenceEnum;
    … …  
    874875              else if (strcmp(name,"Outputdefinition77")==0) return Outputdefinition77Enum;
    875876              else if (strcmp(name,"Outputdefinition78")==0) return Outputdefinition78Enum;
    876               else if (strcmp(name,"Outputdefinition79")==0) return Outputdefinition79Enum;
    877877         else stage=8;
    878878   }
    879879   if(stage==8){
    880               if (strcmp(name,"Outputdefinition80")==0) return Outputdefinition80Enum;
     880              if (strcmp(name,"Outputdefinition79")==0) return Outputdefinition79Enum;
     881              else if (strcmp(name,"Outputdefinition80")==0) return Outputdefinition80Enum;
    881882              else if (strcmp(name,"Outputdefinition81")==0) return Outputdefinition81Enum;
    882883              else if (strcmp(name,"Outputdefinition82")==0) return Outputdefinition82Enum;
    … …  
    997998              else if (strcmp(name,"Sset")==0) return SsetEnum;
    998999              else if (strcmp(name,"Verbose")==0) return VerboseEnum;
    999               else if (strcmp(name,"TriangleInterp")==0) return TriangleInterpEnum;
    10001000         else stage=9;
    10011001   }
    10021002   if(stage==9){
    1003               if (strcmp(name,"BilinearInterp")==0) return BilinearInterpEnum;
     1003              if (strcmp(name,"TriangleInterp")==0) return TriangleInterpEnum;
     1004              else if (strcmp(name,"BilinearInterp")==0) return BilinearInterpEnum;
    10041005              else if (strcmp(name,"NearestInterp")==0) return NearestInterpEnum;
    10051006              else if (strcmp(name,"XY")==0) return XYEnum;
    … …  
    10481049              else if (strcmp(name,"SealevelriseRequestedOutputs")==0) return SealevelriseRequestedOutputsEnum;
    10491050              else if (strcmp(name,"SealevelriseNumRequestedOutputs")==0) return SealevelriseNumRequestedOutputsEnum;
     1051              else if (strcmp(name,"ParametersEND")==0) return ParametersENDEnum;
    10501052              else if (strcmp(name,"MaximumNumberOfDefinitions")==0) return MaximumNumberOfDefinitionsEnum;
    10511053         else stage=10;
Note: See TracChangeset for help on using the changeset viewer.