[3702] | 1 | /*
|
---|
| 2 | * \file Parameters.c
|
---|
| 3 | * \brief: implementation of the Parameters class, derived from DataSet class
|
---|
| 4 | */
|
---|
| 5 |
|
---|
[12706] | 6 | /*Headers: {{{*/
|
---|
[3702] | 7 | #ifdef HAVE_CONFIG_H
|
---|
[9320] | 8 | #include <config.h>
|
---|
[3702] | 9 | #else
|
---|
| 10 | #error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!"
|
---|
| 11 | #endif
|
---|
| 12 |
|
---|
| 13 | #include <vector>
|
---|
| 14 | #include <functional>
|
---|
| 15 | #include <algorithm>
|
---|
| 16 | #include <iostream>
|
---|
| 17 |
|
---|
| 18 | #include "./DataSet.h"
|
---|
| 19 | #include "../shared/shared.h"
|
---|
[3775] | 20 | #include "../include/include.h"
|
---|
[3702] | 21 | #include "../EnumDefinitions/EnumDefinitions.h"
|
---|
| 22 |
|
---|
| 23 | using namespace std;
|
---|
| 24 | /*}}}*/
|
---|
| 25 |
|
---|
| 26 | /*Object constructors and destructor*/
|
---|
[12706] | 27 | /*FUNCTION Parameters::Parameters(){{{*/
|
---|
[3702] | 28 | Parameters::Parameters(){
|
---|
[10522] | 29 | enum_type=ParametersEnum;
|
---|
[3702] | 30 | return;
|
---|
| 31 | }
|
---|
| 32 | /*}}}*/
|
---|
[12706] | 33 | /*FUNCTION Parameters::~Parameters(){{{*/
|
---|
[3702] | 34 | Parameters::~Parameters(){
|
---|
| 35 | return;
|
---|
| 36 | }
|
---|
| 37 | /*}}}*/
|
---|
| 38 |
|
---|
| 39 | /*Object management*/
|
---|
[12706] | 40 | /*FUNCTION Parameters::Exist{{{*/
|
---|
[8263] | 41 | bool Parameters::Exist(int enum_type){
|
---|
| 42 |
|
---|
| 43 | vector<Object*>::iterator object;
|
---|
| 44 | Param* param=NULL;
|
---|
| 45 |
|
---|
| 46 | for ( object=objects.begin() ; object < objects.end(); object++ ){
|
---|
| 47 | param=(Param*)(*object);
|
---|
[9883] | 48 | if(param->InstanceEnum()==enum_type) return true;
|
---|
[8263] | 49 | }
|
---|
| 50 | return false;
|
---|
| 51 | }
|
---|
| 52 | /*}}}*/
|
---|
[12706] | 53 | /*FUNCTION Parameters::FindParam(bool* pbool,int enum_type){{{*/
|
---|
[8376] | 54 | void Parameters::FindParam(bool* pbool,int enum_type){ _assert_(this);
|
---|
[3702] | 55 |
|
---|
| 56 | vector<Object*>::iterator object;
|
---|
| 57 | Param* param=NULL;
|
---|
| 58 |
|
---|
| 59 | for ( object=objects.begin() ; object < objects.end(); object++ ){
|
---|
| 60 |
|
---|
[3766] | 61 | param=(Param*)(*object);
|
---|
[9883] | 62 | if(param->InstanceEnum()==enum_type){
|
---|
[3766] | 63 | param->GetParameterValue(pbool);
|
---|
[8263] | 64 | return;
|
---|
[3702] | 65 | }
|
---|
| 66 | }
|
---|
[13395] | 67 | _error_("could not find parameter " << EnumToStringx(enum_type));
|
---|
[3702] | 68 | }
|
---|
| 69 | /*}}}*/
|
---|
[12706] | 70 | /*FUNCTION Parameters::FindParam(int* pinteger,int enum_type){{{*/
|
---|
[8376] | 71 | void Parameters::FindParam(int* pinteger,int enum_type){ _assert_(this);
|
---|
[3702] | 72 |
|
---|
| 73 | vector<Object*>::iterator object;
|
---|
| 74 | Param* param=NULL;
|
---|
| 75 |
|
---|
| 76 | for ( object=objects.begin() ; object < objects.end(); object++ ){
|
---|
| 77 |
|
---|
[3766] | 78 | param=(Param*)(*object);
|
---|
[9883] | 79 | if(param->InstanceEnum()==enum_type){
|
---|
[3766] | 80 | param->GetParameterValue(pinteger);
|
---|
[8263] | 81 | return;
|
---|
[3702] | 82 | }
|
---|
| 83 | }
|
---|
[13395] | 84 | _error_("could not find parameter " << EnumToStringx(enum_type));
|
---|
[3702] | 85 | }
|
---|
| 86 | /*}}}*/
|
---|
[12706] | 87 | /*FUNCTION Parameters::FindParam(IssmDouble* pscalar, int enum_type){{{*/
|
---|
| 88 | void Parameters::FindParam(IssmDouble* pscalar, int enum_type){ _assert_(this);
|
---|
[3732] | 89 |
|
---|
| 90 | vector<Object*>::iterator object;
|
---|
| 91 | Param* param=NULL;
|
---|
| 92 |
|
---|
| 93 | for ( object=objects.begin() ; object < objects.end(); object++ ){
|
---|
| 94 |
|
---|
[3766] | 95 | param=(Param*)(*object);
|
---|
[9883] | 96 | if(param->InstanceEnum()==enum_type){
|
---|
[3766] | 97 | param->GetParameterValue(pscalar);
|
---|
[8263] | 98 | return;
|
---|
[3732] | 99 | }
|
---|
| 100 | }
|
---|
[13395] | 101 | _error_("could not find parameter " << EnumToStringx(enum_type));
|
---|
[3732] | 102 | }
|
---|
| 103 | /*}}}*/
|
---|
[13395] | 104 | /*FUNCTION Parameters::FindParam(IssmDouble* pscalar, int enum_type,IssmDouble time){{{*/
|
---|
| 105 | void Parameters::FindParam(IssmDouble* pscalar, int enum_type,IssmDouble time){ _assert_(this);
|
---|
| 106 |
|
---|
| 107 | vector<Object*>::iterator object;
|
---|
| 108 | Param* param=NULL;
|
---|
| 109 |
|
---|
| 110 | for ( object=objects.begin() ; object < objects.end(); object++ ){
|
---|
| 111 |
|
---|
| 112 | param=(Param*)(*object);
|
---|
| 113 | if(param->InstanceEnum()==enum_type){
|
---|
| 114 | param->GetParameterValue(pscalar,time);
|
---|
| 115 | return;
|
---|
| 116 | }
|
---|
| 117 | }
|
---|
| 118 | _error_("could not find parameter " << EnumToStringx(enum_type));
|
---|
| 119 | }
|
---|
| 120 | /*}}}*/
|
---|
[12706] | 121 | /*FUNCTION Parameters::FindParam(char** pstring,int enum_type){{{*/
|
---|
[8376] | 122 | void Parameters::FindParam(char** pstring,int enum_type){ _assert_(this);
|
---|
[3702] | 123 |
|
---|
| 124 | vector<Object*>::iterator object;
|
---|
| 125 | Param* param=NULL;
|
---|
| 126 |
|
---|
| 127 | for ( object=objects.begin() ; object < objects.end(); object++ ){
|
---|
| 128 |
|
---|
[3766] | 129 | param=(Param*)(*object);
|
---|
[9883] | 130 | if(param->InstanceEnum()==enum_type){
|
---|
[3766] | 131 | param->GetParameterValue(pstring);
|
---|
[8263] | 132 | return;
|
---|
[3702] | 133 | }
|
---|
| 134 | }
|
---|
[13395] | 135 | _error_("could not find parameter " << EnumToStringx(enum_type));
|
---|
[3702] | 136 |
|
---|
| 137 | }
|
---|
| 138 | /*}}}*/
|
---|
[12706] | 139 | /*FUNCTION Parameters::FindParam(char*** pstringarray,int* pM,int enum_type){{{*/
|
---|
[8376] | 140 | void Parameters::FindParam(char*** pstringarray,int* pM,int enum_type){ _assert_(this);
|
---|
[3702] | 141 |
|
---|
| 142 | vector<Object*>::iterator object;
|
---|
| 143 | Param* param=NULL;
|
---|
| 144 |
|
---|
| 145 | for ( object=objects.begin() ; object < objects.end(); object++ ){
|
---|
| 146 |
|
---|
[3766] | 147 | param=(Param*)(*object);
|
---|
[9883] | 148 | if(param->InstanceEnum()==enum_type){
|
---|
[3766] | 149 | param->GetParameterValue(pstringarray,pM);
|
---|
[8263] | 150 | return;
|
---|
[3702] | 151 | }
|
---|
| 152 | }
|
---|
[13395] | 153 | _error_("could not find parameter " << EnumToStringx(enum_type));
|
---|
[3702] | 154 |
|
---|
| 155 | }
|
---|
| 156 | /*}}}*/
|
---|
[12706] | 157 | /*FUNCTION Parameters::FindParam(int** pintarray,int* pM,int enum_type){{{*/
|
---|
[8376] | 158 | void Parameters::FindParam(int** pintarray,int* pM, int enum_type){ _assert_(this);
|
---|
[6213] | 159 |
|
---|
| 160 | vector<Object*>::iterator object;
|
---|
| 161 | Param* param=NULL;
|
---|
| 162 |
|
---|
| 163 | for ( object=objects.begin() ; object < objects.end(); object++ ){
|
---|
| 164 |
|
---|
| 165 | param=(Param*)(*object);
|
---|
[9883] | 166 | if(param->InstanceEnum()==enum_type){
|
---|
[6213] | 167 | param->GetParameterValue(pintarray,pM);
|
---|
[8263] | 168 | return;
|
---|
[6213] | 169 | }
|
---|
| 170 | }
|
---|
[13395] | 171 | _error_("could not find parameter " << EnumToStringx(enum_type));
|
---|
[6213] | 172 |
|
---|
| 173 | }
|
---|
| 174 | /*}}}*/
|
---|
[12706] | 175 | /*FUNCTION Parameters::FindParam(int** pintarray,int* pM,int* pN,int enum_type){{{*/
|
---|
[8600] | 176 | void Parameters::FindParam(int** pintarray,int* pM,int *pN,int enum_type){ _assert_(this);
|
---|
| 177 |
|
---|
| 178 | vector<Object*>::iterator object;
|
---|
| 179 | Param* param=NULL;
|
---|
| 180 |
|
---|
| 181 | for ( object=objects.begin() ; object < objects.end(); object++ ){
|
---|
| 182 |
|
---|
| 183 | param=(Param*)(*object);
|
---|
[9883] | 184 | if(param->InstanceEnum()==enum_type){
|
---|
[8600] | 185 | param->GetParameterValue(pintarray,pM,pN);
|
---|
| 186 | return;
|
---|
| 187 | }
|
---|
| 188 | }
|
---|
[13395] | 189 | _error_("could not find parameter " << EnumToStringx(enum_type));
|
---|
[8600] | 190 |
|
---|
| 191 | }
|
---|
| 192 | /*}}}*/
|
---|
[12706] | 193 | /*FUNCTION Parameters::FindParam(IssmDouble** pIssmDoublearray,int* pM,int enum_type){{{*/
|
---|
| 194 | void Parameters::FindParam(IssmDouble** pIssmDoublearray,int* pM, int enum_type){ _assert_(this);
|
---|
[8263] | 195 |
|
---|
[3702] | 196 | vector<Object*>::iterator object;
|
---|
| 197 | Param* param=NULL;
|
---|
| 198 |
|
---|
| 199 | for ( object=objects.begin() ; object < objects.end(); object++ ){
|
---|
| 200 |
|
---|
[3766] | 201 | param=(Param*)(*object);
|
---|
[9883] | 202 | if(param->InstanceEnum()==enum_type){
|
---|
[12706] | 203 | param->GetParameterValue(pIssmDoublearray,pM);
|
---|
[8263] | 204 | return;
|
---|
[3702] | 205 | }
|
---|
| 206 | }
|
---|
[13395] | 207 | _error_("could not find parameter " << EnumToStringx(enum_type));
|
---|
[3702] | 208 |
|
---|
| 209 | }
|
---|
| 210 | /*}}}*/
|
---|
[12706] | 211 | /*FUNCTION Parameters::FindParam(IssmDouble** pIssmDoublearray,int* pM, int* pN,int enum_type){{{*/
|
---|
| 212 | void Parameters::FindParam(IssmDouble** pIssmDoublearray,int* pM, int* pN,int enum_type){ _assert_(this);
|
---|
[8263] | 213 |
|
---|
[3702] | 214 | vector<Object*>::iterator object;
|
---|
| 215 | Param* param=NULL;
|
---|
| 216 |
|
---|
| 217 | for ( object=objects.begin() ; object < objects.end(); object++ ){
|
---|
| 218 |
|
---|
[3766] | 219 | param=(Param*)(*object);
|
---|
[9883] | 220 | if(param->InstanceEnum()==enum_type){
|
---|
[12706] | 221 | param->GetParameterValue(pIssmDoublearray,pM,pN);
|
---|
[8263] | 222 | return;
|
---|
[3702] | 223 | }
|
---|
| 224 | }
|
---|
[13395] | 225 | _error_("could not find parameter " << EnumToStringx(enum_type));
|
---|
[3702] | 226 |
|
---|
| 227 | }
|
---|
| 228 | /*}}}*/
|
---|
[12706] | 229 | /*FUNCTION Parameters::FindParam(IssmDouble*** parray,int* pM,int** pmdims_array,int** pndims_array,int enum_type){{{*/
|
---|
| 230 | void Parameters::FindParam(IssmDouble*** parray,int* pM,int** pmdims_array,int** pndims_array,int enum_type){ _assert_(this);
|
---|
[4855] | 231 |
|
---|
| 232 | vector<Object*>::iterator object;
|
---|
| 233 | Param* param=NULL;
|
---|
| 234 |
|
---|
| 235 | for ( object=objects.begin() ; object < objects.end(); object++ ){
|
---|
| 236 |
|
---|
| 237 | param=(Param*)(*object);
|
---|
[9883] | 238 | if(param->InstanceEnum()==enum_type){
|
---|
[4855] | 239 | param->GetParameterValue(parray,pM,pmdims_array,pndims_array);
|
---|
[8263] | 240 | return;
|
---|
[4855] | 241 | }
|
---|
| 242 | }
|
---|
[13395] | 243 | _error_("could not find parameter " << EnumToStringx(enum_type));
|
---|
[4855] | 244 | }
|
---|
| 245 | /*}}}*/
|
---|
[13395] | 246 | /*FUNCTION Parameters::FindParam(Vector<IssmDouble>** pvec,int enum_type){{{*/
|
---|
| 247 | void Parameters::FindParam(Vector<IssmDouble>** pvec,int enum_type){ _assert_(this);
|
---|
[3702] | 248 |
|
---|
| 249 | vector<Object*>::iterator object;
|
---|
| 250 | Param* param=NULL;
|
---|
| 251 |
|
---|
| 252 | for ( object=objects.begin() ; object < objects.end(); object++ ){
|
---|
| 253 |
|
---|
[3766] | 254 | param=(Param*)(*object);
|
---|
[9883] | 255 | if(param->InstanceEnum()==enum_type){
|
---|
[3766] | 256 | param->GetParameterValue(pvec);
|
---|
[8263] | 257 | return;
|
---|
[3702] | 258 | }
|
---|
| 259 | }
|
---|
[13395] | 260 | _error_("could not find parameter " << EnumToStringx(enum_type));
|
---|
[3702] | 261 |
|
---|
| 262 | }
|
---|
| 263 | /*}}}*/
|
---|
[13395] | 264 | /*FUNCTION Parameters::FindParam(Matrix<IssmDouble>** pmat,int enum_type){{{*/
|
---|
| 265 | void Parameters::FindParam(Matrix<IssmDouble>** pmat,int enum_type){ _assert_(this);
|
---|
[3702] | 266 |
|
---|
| 267 | vector<Object*>::iterator object;
|
---|
| 268 | Param* param=NULL;
|
---|
| 269 |
|
---|
| 270 | for ( object=objects.begin() ; object < objects.end(); object++ ){
|
---|
| 271 |
|
---|
[3766] | 272 | param=(Param*)(*object);
|
---|
[9883] | 273 | if(param->InstanceEnum()==enum_type){
|
---|
[3766] | 274 | param->GetParameterValue(pmat);
|
---|
[8263] | 275 | return;
|
---|
[3702] | 276 | }
|
---|
| 277 | }
|
---|
[13395] | 278 | _error_("could not find parameter " << EnumToStringx(enum_type));
|
---|
[3702] | 279 |
|
---|
| 280 | }
|
---|
| 281 | /*}}}*/
|
---|
[12706] | 282 | /*FUNCTION Parameters::FindParam(FILE** pfid,int enum_type){{{*/
|
---|
[8376] | 283 | void Parameters::FindParam(FILE** pfid,int enum_type){ _assert_(this);
|
---|
[4059] | 284 |
|
---|
[4873] | 285 | vector<Object*>::iterator object;
|
---|
| 286 | Param* param=NULL;
|
---|
| 287 |
|
---|
| 288 | for ( object=objects.begin() ; object < objects.end(); object++ ){
|
---|
| 289 |
|
---|
| 290 | param=(Param*)(*object);
|
---|
[9883] | 291 | if(param->InstanceEnum()==enum_type){
|
---|
[4873] | 292 | param->GetParameterValue(pfid);
|
---|
[8263] | 293 | return;
|
---|
[4873] | 294 | }
|
---|
| 295 | }
|
---|
[13395] | 296 | _error_("could not find parameter " << EnumToStringx(enum_type));
|
---|
[4873] | 297 | }
|
---|
| 298 | /*}}}*/
|
---|
| 299 |
|
---|
[12706] | 300 | /*FUNCTION Parameters::SetParam(bool boolean,int enum_type);{{{*/
|
---|
[4059] | 301 | void Parameters::SetParam(bool boolean,int enum_type){
|
---|
| 302 |
|
---|
| 303 | Param* param=NULL;
|
---|
| 304 |
|
---|
| 305 | /*first, figure out if the param has already been created: */
|
---|
| 306 | param=(Param*)this->FindParamObject(enum_type);
|
---|
| 307 |
|
---|
| 308 | if(param) param->SetValue(boolean); //already exists, just set it.
|
---|
| 309 | else this->AddObject(new BoolParam(enum_type,boolean)); //just add the new parameter.
|
---|
| 310 | }
|
---|
| 311 | /*}}}*/
|
---|
[12706] | 312 | /*FUNCTION Parameters::SetParam(int integer,int enum_type);{{{*/
|
---|
[4059] | 313 | void Parameters::SetParam(int integer,int enum_type){
|
---|
| 314 |
|
---|
| 315 | Param* param=NULL;
|
---|
| 316 |
|
---|
| 317 | /*first, figure out if the param has already been created: */
|
---|
| 318 | param=(Param*)this->FindParamObject(enum_type);
|
---|
| 319 |
|
---|
| 320 | if(param) param->SetValue(integer); //already exists, just set it.
|
---|
| 321 | else this->AddObject(new IntParam(enum_type,integer)); //just add the new parameter.
|
---|
| 322 | }
|
---|
| 323 | /*}}}*/
|
---|
[12706] | 324 | /*FUNCTION Parameters::SetParam(IssmDouble scalar,int enum_type);{{{*/
|
---|
| 325 | void Parameters::SetParam(IssmDouble scalar,int enum_type){
|
---|
[4059] | 326 |
|
---|
| 327 | Param* param=NULL;
|
---|
| 328 |
|
---|
| 329 | /*first, figure out if the param has already been created: */
|
---|
| 330 | param=(Param*)this->FindParamObject(enum_type);
|
---|
| 331 |
|
---|
| 332 | if(param) param->SetValue(scalar); //already exists, just set it.
|
---|
| 333 | else this->AddObject(new DoubleParam(enum_type,scalar)); //just add the new parameter.
|
---|
| 334 | }
|
---|
| 335 | /*}}}*/
|
---|
[12706] | 336 | /*FUNCTION Parameters::SetParam(char* string,int enum_type);{{{*/
|
---|
[4059] | 337 | void Parameters::SetParam(char* string,int enum_type){
|
---|
| 338 |
|
---|
| 339 | Param* param=NULL;
|
---|
| 340 |
|
---|
| 341 | /*first, figure out if the param has already been created: */
|
---|
| 342 | param=(Param*)this->FindParamObject(enum_type);
|
---|
| 343 |
|
---|
| 344 | if(param) param->SetValue(string); //already exists, just set it.
|
---|
| 345 | else this->AddObject(new StringParam(enum_type,string)); //just add the new parameter.
|
---|
| 346 | }
|
---|
| 347 | /*}}}*/
|
---|
[12706] | 348 | /*FUNCTION Parameters::SetParam(char** stringarray,int M, int enum_type);{{{*/
|
---|
[4059] | 349 | void Parameters::SetParam(char** stringarray,int M, int enum_type){
|
---|
| 350 |
|
---|
| 351 | Param* param=NULL;
|
---|
| 352 |
|
---|
| 353 | /*first, figure out if the param has already been created: */
|
---|
| 354 | param=(Param*)this->FindParamObject(enum_type);
|
---|
| 355 |
|
---|
| 356 | if(param) param->SetValue(stringarray,M); //already exists, just set it.
|
---|
| 357 | else this->AddObject(new StringArrayParam(enum_type,stringarray,M)); //just add the new parameter.
|
---|
| 358 | }
|
---|
| 359 | /*}}}*/
|
---|
[12706] | 360 | /*FUNCTION Parameters::SetParam(IssmDouble* IssmDoublearray,int M,int enum_type);{{{*/
|
---|
| 361 | void Parameters::SetParam(IssmDouble* IssmDoublearray,int M, int enum_type){
|
---|
[4059] | 362 |
|
---|
| 363 | Param* param=NULL;
|
---|
| 364 |
|
---|
| 365 | /*first, figure out if the param has already been created: */
|
---|
| 366 | param=(Param*)this->FindParamObject(enum_type);
|
---|
| 367 |
|
---|
[12706] | 368 | if(param) param->SetValue(IssmDoublearray,M); //already exists, just set it.
|
---|
| 369 | else this->AddObject(new DoubleVecParam(enum_type,IssmDoublearray,M)); //just add the new parameter.
|
---|
[4059] | 370 | }
|
---|
| 371 | /*}}}*/
|
---|
[12706] | 372 | /*FUNCTION Parameters::SetParam(IssmDouble* IssmDoublearray,int M,int N, int enum_type);{{{*/
|
---|
| 373 | void Parameters::SetParam(IssmDouble* IssmDoublearray,int M, int N, int enum_type){
|
---|
[4059] | 374 |
|
---|
| 375 | Param* param=NULL;
|
---|
| 376 |
|
---|
| 377 | /*first, figure out if the param has already been created: */
|
---|
| 378 | param=(Param*)this->FindParamObject(enum_type);
|
---|
| 379 |
|
---|
[12706] | 380 | if(param) param->SetValue(IssmDoublearray,M,N); //already exists, just set it.
|
---|
| 381 | else this->AddObject(new DoubleMatParam(enum_type,IssmDoublearray,M,N)); //just add the new parameter.
|
---|
[4059] | 382 | }
|
---|
| 383 | /*}}}*/
|
---|
[12706] | 384 | /*FUNCTION Parameters::SetParam(int* intarray,int M,int enum_type);{{{*/
|
---|
[8600] | 385 | void Parameters::SetParam(int* intarray,int M, int enum_type){
|
---|
| 386 |
|
---|
| 387 | Param* param=NULL;
|
---|
| 388 |
|
---|
| 389 | /*first, figure out if the param has already been created: */
|
---|
| 390 | param=(Param*)this->FindParamObject(enum_type);
|
---|
| 391 |
|
---|
| 392 | if(param) param->SetValue(intarray,M); //already exists, just set it.
|
---|
| 393 | else this->AddObject(new IntVecParam(enum_type,intarray,M)); //just add the new parameter.
|
---|
| 394 | }
|
---|
| 395 | /*}}}*/
|
---|
[12706] | 396 | /*FUNCTION Parameters::SetParam(int* intarray,int M,int N, int enum_type);{{{*/
|
---|
[8600] | 397 | void Parameters::SetParam(int* intarray,int M, int N, int enum_type){
|
---|
| 398 |
|
---|
| 399 | Param* param=NULL;
|
---|
| 400 |
|
---|
| 401 | /*first, figure out if the param has already been created: */
|
---|
| 402 | param=(Param*)this->FindParamObject(enum_type);
|
---|
| 403 |
|
---|
| 404 | if(param) param->SetValue(intarray,M,N); //already exists, just set it.
|
---|
| 405 | else this->AddObject(new IntMatParam(enum_type,intarray,M,N)); //just add the new parameter.
|
---|
| 406 | }
|
---|
| 407 | /*}}}*/
|
---|
[13395] | 408 | /*FUNCTION Parameters::SetParam(Vector<IssmDouble>* vector,int enum_type);{{{*/
|
---|
| 409 | void Parameters::SetParam(Vector<IssmDouble>* vector,int enum_type){
|
---|
[4059] | 410 |
|
---|
| 411 | Param* param=NULL;
|
---|
| 412 |
|
---|
| 413 | /*first, figure out if the param has already been created: */
|
---|
| 414 | param=(Param*)this->FindParamObject(enum_type);
|
---|
| 415 |
|
---|
| 416 | if(param) param->SetValue(vector); //already exists, just set it.
|
---|
[11995] | 417 | else this->AddObject(new VectorParam(enum_type,vector)); //just add the new parameter.
|
---|
[4059] | 418 | }
|
---|
| 419 | /*}}}*/
|
---|
[13395] | 420 | /*FUNCTION Parameters::SetParam(Matrix<IssmDouble>* matrix,int enum_type);{{{*/
|
---|
| 421 | void Parameters::SetParam(Matrix<IssmDouble>* matrix,int enum_type){
|
---|
[4059] | 422 |
|
---|
| 423 | Param* param=NULL;
|
---|
| 424 |
|
---|
| 425 | /*first, figure out if the param has already been created: */
|
---|
| 426 | param=(Param*)this->FindParamObject(enum_type);
|
---|
| 427 |
|
---|
| 428 | if(param) param->SetValue(matrix); //already exists, just set it.
|
---|
[11995] | 429 | else this->AddObject(new MatrixParam(enum_type,matrix)); //just add the new parameter.
|
---|
[4059] | 430 | }
|
---|
| 431 | /*}}}*/
|
---|
[12706] | 432 | /*FUNCTION Parameters::SetParam(FILE* fid,int enum_type);{{{*/
|
---|
[4873] | 433 | void Parameters::SetParam(FILE* fid,int enum_type){
|
---|
[4059] | 434 |
|
---|
[4873] | 435 | Param* param=NULL;
|
---|
| 436 |
|
---|
| 437 | /*first, figure out if the param has already been created: */
|
---|
| 438 | param=(Param*)this->FindParamObject(enum_type);
|
---|
| 439 |
|
---|
| 440 | if(param) param->SetValue(fid); //already exists, just set it.
|
---|
| 441 | else this->AddObject(new FileParam(enum_type,fid)); //just add the new parameter.
|
---|
| 442 | }
|
---|
| 443 | /*}}}*/
|
---|
[12706] | 444 | /*FUNCTION Parameters::UnitConversion(int direction_enum);{{{*/
|
---|
[9356] | 445 | void Parameters::UnitConversion(int direction_enum){
|
---|
[4873] | 446 |
|
---|
[9356] | 447 | vector<Object*>::iterator object;
|
---|
| 448 | Param* param=NULL;
|
---|
| 449 |
|
---|
| 450 | for ( object=objects.begin() ; object < objects.end(); object++ ){
|
---|
| 451 | param=(Param*)(*object);
|
---|
| 452 | param->UnitConversion(direction_enum);
|
---|
| 453 | }
|
---|
| 454 |
|
---|
| 455 | }
|
---|
| 456 | /*}}}*/
|
---|
| 457 |
|
---|
[12706] | 458 | /*FUNCTION Parameters::FindParamObject{{{*/
|
---|
[3702] | 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 |
|
---|
[3766] | 466 | param=(Param*)(*object);
|
---|
[9883] | 467 | if(param->InstanceEnum()==enum_type){
|
---|
[3766] | 468 | return (*object);
|
---|
[3702] | 469 | }
|
---|
| 470 | }
|
---|
| 471 | return NULL;
|
---|
| 472 | }
|
---|
| 473 | /*}}}*/
|
---|