[3702] | 1 | /*
|
---|
| 2 | * \file Parameters.c
|
---|
| 3 | * \brief: implementation of the Parameters class, derived from DataSet class
|
---|
| 4 | */
|
---|
| 5 |
|
---|
| 6 | /*Headers: {{{1*/
|
---|
| 7 | #ifdef HAVE_CONFIG_H
|
---|
| 8 | #include "config.h"
|
---|
| 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*/
|
---|
[3766] | 27 | /*FUNCTION Parameters::Parameters(){{{1*/
|
---|
[3702] | 28 | Parameters::Parameters(){
|
---|
| 29 | return;
|
---|
| 30 | }
|
---|
| 31 | /*}}}*/
|
---|
[3766] | 32 | /*FUNCTION Parameters::Parameters(int in_enum){{{1*/
|
---|
[3702] | 33 | Parameters::Parameters(int in_enum): DataSet(in_enum){
|
---|
| 34 | //do nothing;
|
---|
| 35 | return;
|
---|
| 36 | }
|
---|
| 37 | /*}}}*/
|
---|
[3766] | 38 | /*FUNCTION Parameters::~Parameters(){{{1*/
|
---|
[3702] | 39 | Parameters::~Parameters(){
|
---|
| 40 | return;
|
---|
| 41 | }
|
---|
| 42 | /*}}}*/
|
---|
| 43 |
|
---|
| 44 | /*Object management*/
|
---|
[8263] | 45 | /*FUNCTION Parameters::Exist{{{1*/
|
---|
| 46 | bool Parameters::Exist(int enum_type){
|
---|
| 47 |
|
---|
| 48 | vector<Object*>::iterator object;
|
---|
| 49 | Param* param=NULL;
|
---|
| 50 |
|
---|
| 51 | for ( object=objects.begin() ; object < objects.end(); object++ ){
|
---|
| 52 | param=(Param*)(*object);
|
---|
| 53 | if(param->EnumType()==enum_type) return true;
|
---|
| 54 | }
|
---|
| 55 | return false;
|
---|
| 56 | }
|
---|
| 57 | /*}}}*/
|
---|
[3766] | 58 | /*FUNCTION Parameters::FindParam(bool* pbool,int enum_type){{{1*/
|
---|
[8376] | 59 | void Parameters::FindParam(bool* pbool,int enum_type){ _assert_(this);
|
---|
[3702] | 60 |
|
---|
| 61 | vector<Object*>::iterator object;
|
---|
| 62 | Param* param=NULL;
|
---|
| 63 |
|
---|
| 64 | for ( object=objects.begin() ; object < objects.end(); object++ ){
|
---|
| 65 |
|
---|
[3766] | 66 | param=(Param*)(*object);
|
---|
| 67 | if(param->EnumType()==enum_type){
|
---|
| 68 | param->GetParameterValue(pbool);
|
---|
[8263] | 69 | return;
|
---|
[3702] | 70 | }
|
---|
| 71 | }
|
---|
[8263] | 72 | _error_("could not find parameter %s",EnumToStringx(enum_type));
|
---|
[3702] | 73 | }
|
---|
| 74 | /*}}}*/
|
---|
[3766] | 75 | /*FUNCTION Parameters::FindParam(int* pinteger,int enum_type){{{1*/
|
---|
[8376] | 76 | void Parameters::FindParam(int* pinteger,int enum_type){ _assert_(this);
|
---|
[3702] | 77 |
|
---|
| 78 | vector<Object*>::iterator object;
|
---|
| 79 | Param* param=NULL;
|
---|
| 80 |
|
---|
| 81 | for ( object=objects.begin() ; object < objects.end(); object++ ){
|
---|
| 82 |
|
---|
[3766] | 83 | param=(Param*)(*object);
|
---|
| 84 | if(param->EnumType()==enum_type){
|
---|
| 85 | param->GetParameterValue(pinteger);
|
---|
[8263] | 86 | return;
|
---|
[3702] | 87 | }
|
---|
| 88 | }
|
---|
[8263] | 89 | _error_("could not find parameter %s",EnumToStringx(enum_type));
|
---|
[3702] | 90 | }
|
---|
| 91 | /*}}}*/
|
---|
[3766] | 92 | /*FUNCTION Parameters::FindParam(double* pscalar, int enum_type){{{1*/
|
---|
[8376] | 93 | void Parameters::FindParam(double* pscalar, int enum_type){ _assert_(this);
|
---|
[3732] | 94 |
|
---|
| 95 | vector<Object*>::iterator object;
|
---|
| 96 | Param* param=NULL;
|
---|
| 97 |
|
---|
| 98 | for ( object=objects.begin() ; object < objects.end(); object++ ){
|
---|
| 99 |
|
---|
[3766] | 100 | param=(Param*)(*object);
|
---|
| 101 | if(param->EnumType()==enum_type){
|
---|
| 102 | param->GetParameterValue(pscalar);
|
---|
[8263] | 103 | return;
|
---|
[3732] | 104 | }
|
---|
| 105 | }
|
---|
[8263] | 106 | _error_("could not find parameter %s",EnumToStringx(enum_type));
|
---|
[3732] | 107 | }
|
---|
| 108 | /*}}}*/
|
---|
[3766] | 109 | /*FUNCTION Parameters::FindParam(char** pstring,int enum_type){{{1*/
|
---|
[8376] | 110 | void Parameters::FindParam(char** pstring,int enum_type){ _assert_(this);
|
---|
[3702] | 111 |
|
---|
| 112 | vector<Object*>::iterator object;
|
---|
| 113 | Param* param=NULL;
|
---|
| 114 |
|
---|
| 115 | for ( object=objects.begin() ; object < objects.end(); object++ ){
|
---|
| 116 |
|
---|
[3766] | 117 | param=(Param*)(*object);
|
---|
| 118 | if(param->EnumType()==enum_type){
|
---|
| 119 | param->GetParameterValue(pstring);
|
---|
[8263] | 120 | return;
|
---|
[3702] | 121 | }
|
---|
| 122 | }
|
---|
[8263] | 123 | _error_("could not find parameter %s",EnumToStringx(enum_type));
|
---|
[3702] | 124 |
|
---|
| 125 | }
|
---|
| 126 | /*}}}*/
|
---|
[3766] | 127 | /*FUNCTION Parameters::FindParam(char*** pstringarray,int* pM,int enum_type){{{1*/
|
---|
[8376] | 128 | void Parameters::FindParam(char*** pstringarray,int* pM,int enum_type){ _assert_(this);
|
---|
[3702] | 129 |
|
---|
| 130 | vector<Object*>::iterator object;
|
---|
| 131 | Param* param=NULL;
|
---|
| 132 |
|
---|
| 133 | for ( object=objects.begin() ; object < objects.end(); object++ ){
|
---|
| 134 |
|
---|
[3766] | 135 | param=(Param*)(*object);
|
---|
| 136 | if(param->EnumType()==enum_type){
|
---|
| 137 | param->GetParameterValue(pstringarray,pM);
|
---|
[8263] | 138 | return;
|
---|
[3702] | 139 | }
|
---|
| 140 | }
|
---|
[8263] | 141 | _error_("could not find parameter %s",EnumToStringx(enum_type));
|
---|
[3702] | 142 |
|
---|
| 143 | }
|
---|
| 144 | /*}}}*/
|
---|
[6213] | 145 | /*FUNCTION Parameters::FindParam(int** pintarray,int* pM,int enum_type){{{1*/
|
---|
[8376] | 146 | void Parameters::FindParam(int** pintarray,int* pM, int enum_type){ _assert_(this);
|
---|
[6213] | 147 |
|
---|
| 148 | vector<Object*>::iterator object;
|
---|
| 149 | Param* param=NULL;
|
---|
| 150 |
|
---|
| 151 | for ( object=objects.begin() ; object < objects.end(); object++ ){
|
---|
| 152 |
|
---|
| 153 | param=(Param*)(*object);
|
---|
| 154 | if(param->EnumType()==enum_type){
|
---|
| 155 | param->GetParameterValue(pintarray,pM);
|
---|
[8263] | 156 | return;
|
---|
[6213] | 157 | }
|
---|
| 158 | }
|
---|
[8263] | 159 | _error_("could not find parameter %s",EnumToStringx(enum_type));
|
---|
[6213] | 160 |
|
---|
| 161 | }
|
---|
| 162 | /*}}}*/
|
---|
[3766] | 163 | /*FUNCTION Parameters::FindParam(double** pdoublearray,int* pM,int enum_type){{{1*/
|
---|
[8376] | 164 | void Parameters::FindParam(double** pdoublearray,int* pM, int enum_type){ _assert_(this);
|
---|
[8263] | 165 |
|
---|
[3702] | 166 | vector<Object*>::iterator object;
|
---|
| 167 | Param* param=NULL;
|
---|
| 168 |
|
---|
| 169 | for ( object=objects.begin() ; object < objects.end(); object++ ){
|
---|
| 170 |
|
---|
[3766] | 171 | param=(Param*)(*object);
|
---|
| 172 | if(param->EnumType()==enum_type){
|
---|
| 173 | param->GetParameterValue(pdoublearray,pM);
|
---|
[8263] | 174 | return;
|
---|
[3702] | 175 | }
|
---|
| 176 | }
|
---|
[8263] | 177 | _error_("could not find parameter %s",EnumToStringx(enum_type));
|
---|
[3702] | 178 |
|
---|
| 179 | }
|
---|
| 180 | /*}}}*/
|
---|
[3766] | 181 | /*FUNCTION Parameters::FindParam(double** pdoublearray,int* pM, int* pN,int enum_type){{{1*/
|
---|
[8376] | 182 | void Parameters::FindParam(double** pdoublearray,int* pM, int* pN,int enum_type){ _assert_(this);
|
---|
[8263] | 183 |
|
---|
[3702] | 184 | vector<Object*>::iterator object;
|
---|
| 185 | Param* param=NULL;
|
---|
| 186 |
|
---|
| 187 | for ( object=objects.begin() ; object < objects.end(); object++ ){
|
---|
| 188 |
|
---|
[3766] | 189 | param=(Param*)(*object);
|
---|
| 190 | if(param->EnumType()==enum_type){
|
---|
| 191 | param->GetParameterValue(pdoublearray,pM,pN);
|
---|
[8263] | 192 | return;
|
---|
[3702] | 193 | }
|
---|
| 194 | }
|
---|
[8263] | 195 | _error_("could not find parameter %s",EnumToStringx(enum_type));
|
---|
[3702] | 196 |
|
---|
| 197 | }
|
---|
| 198 | /*}}}*/
|
---|
[4855] | 199 | /*FUNCTION Parameters::FindParam(double*** parray,int* pM,int** pmdims_array,int** pndims_array,int enum_type){{{1*/
|
---|
[8376] | 200 | void Parameters::FindParam(double*** parray,int* pM,int** pmdims_array,int** pndims_array,int enum_type){ _assert_(this);
|
---|
[4855] | 201 |
|
---|
| 202 | vector<Object*>::iterator object;
|
---|
| 203 | Param* param=NULL;
|
---|
| 204 |
|
---|
| 205 | for ( object=objects.begin() ; object < objects.end(); object++ ){
|
---|
| 206 |
|
---|
| 207 | param=(Param*)(*object);
|
---|
| 208 | if(param->EnumType()==enum_type){
|
---|
| 209 | param->GetParameterValue(parray,pM,pmdims_array,pndims_array);
|
---|
[8263] | 210 | return;
|
---|
[4855] | 211 | }
|
---|
| 212 | }
|
---|
[8263] | 213 | _error_("could not find parameter %s",EnumToStringx(enum_type));
|
---|
[4855] | 214 | }
|
---|
| 215 | /*}}}*/
|
---|
[3766] | 216 | /*FUNCTION Parameters::FindParam(Vec* pvec,int enum_type){{{1*/
|
---|
[8376] | 217 | void Parameters::FindParam(Vec* pvec,int enum_type){ _assert_(this);
|
---|
[3702] | 218 |
|
---|
| 219 | vector<Object*>::iterator object;
|
---|
| 220 | Param* param=NULL;
|
---|
| 221 |
|
---|
| 222 | for ( object=objects.begin() ; object < objects.end(); object++ ){
|
---|
| 223 |
|
---|
[3766] | 224 | param=(Param*)(*object);
|
---|
| 225 | if(param->EnumType()==enum_type){
|
---|
| 226 | param->GetParameterValue(pvec);
|
---|
[8263] | 227 | return;
|
---|
[3702] | 228 | }
|
---|
| 229 | }
|
---|
[8263] | 230 | _error_("could not find parameter %s",EnumToStringx(enum_type));
|
---|
[3702] | 231 |
|
---|
| 232 | }
|
---|
| 233 | /*}}}*/
|
---|
[4059] | 234 | /*FUNCTION Parameters::FindParam(Mat* pmat,int enum_type){{{1*/
|
---|
[8376] | 235 | void Parameters::FindParam(Mat* pmat,int enum_type){ _assert_(this);
|
---|
[3702] | 236 |
|
---|
| 237 | vector<Object*>::iterator object;
|
---|
| 238 | Param* param=NULL;
|
---|
| 239 |
|
---|
| 240 | for ( object=objects.begin() ; object < objects.end(); object++ ){
|
---|
| 241 |
|
---|
[3766] | 242 | param=(Param*)(*object);
|
---|
| 243 | if(param->EnumType()==enum_type){
|
---|
| 244 | param->GetParameterValue(pmat);
|
---|
[8263] | 245 | return;
|
---|
[3702] | 246 | }
|
---|
| 247 | }
|
---|
[8263] | 248 | _error_("could not find parameter %s",EnumToStringx(enum_type));
|
---|
[3702] | 249 |
|
---|
| 250 | }
|
---|
| 251 | /*}}}*/
|
---|
[4873] | 252 | /*FUNCTION Parameters::FindParam(FILE** pfid,int enum_type){{{1*/
|
---|
[8376] | 253 | void Parameters::FindParam(FILE** pfid,int enum_type){ _assert_(this);
|
---|
[4059] | 254 |
|
---|
[4873] | 255 | vector<Object*>::iterator object;
|
---|
| 256 | Param* param=NULL;
|
---|
| 257 |
|
---|
| 258 | for ( object=objects.begin() ; object < objects.end(); object++ ){
|
---|
| 259 |
|
---|
| 260 | param=(Param*)(*object);
|
---|
| 261 | if(param->EnumType()==enum_type){
|
---|
| 262 | param->GetParameterValue(pfid);
|
---|
[8263] | 263 | return;
|
---|
[4873] | 264 | }
|
---|
| 265 | }
|
---|
[8263] | 266 | _error_("could not find parameter %s",EnumToStringx(enum_type));
|
---|
[4873] | 267 | }
|
---|
| 268 | /*}}}*/
|
---|
| 269 |
|
---|
[4059] | 270 | /*FUNCTION Parameters::SetParam(bool boolean,int enum_type);{{{1*/
|
---|
| 271 | void Parameters::SetParam(bool boolean,int enum_type){
|
---|
| 272 |
|
---|
| 273 | Param* param=NULL;
|
---|
| 274 |
|
---|
| 275 | /*first, figure out if the param has already been created: */
|
---|
| 276 | param=(Param*)this->FindParamObject(enum_type);
|
---|
| 277 |
|
---|
| 278 | if(param) param->SetValue(boolean); //already exists, just set it.
|
---|
| 279 | else this->AddObject(new BoolParam(enum_type,boolean)); //just add the new parameter.
|
---|
| 280 | }
|
---|
| 281 | /*}}}*/
|
---|
| 282 | /*FUNCTION Parameters::SetParam(int integer,int enum_type);{{{1*/
|
---|
| 283 | void Parameters::SetParam(int integer,int enum_type){
|
---|
| 284 |
|
---|
| 285 | Param* param=NULL;
|
---|
| 286 |
|
---|
| 287 | /*first, figure out if the param has already been created: */
|
---|
| 288 | param=(Param*)this->FindParamObject(enum_type);
|
---|
| 289 |
|
---|
| 290 | if(param) param->SetValue(integer); //already exists, just set it.
|
---|
| 291 | else this->AddObject(new IntParam(enum_type,integer)); //just add the new parameter.
|
---|
| 292 | }
|
---|
| 293 | /*}}}*/
|
---|
| 294 | /*FUNCTION Parameters::SetParam(double scalar,int enum_type);{{{1*/
|
---|
| 295 | void Parameters::SetParam(double scalar,int enum_type){
|
---|
| 296 |
|
---|
| 297 | Param* param=NULL;
|
---|
| 298 |
|
---|
| 299 | /*first, figure out if the param has already been created: */
|
---|
| 300 | param=(Param*)this->FindParamObject(enum_type);
|
---|
| 301 |
|
---|
| 302 | if(param) param->SetValue(scalar); //already exists, just set it.
|
---|
| 303 | else this->AddObject(new DoubleParam(enum_type,scalar)); //just add the new parameter.
|
---|
| 304 | }
|
---|
| 305 | /*}}}*/
|
---|
| 306 | /*FUNCTION Parameters::SetParam(char* string,int enum_type);{{{1*/
|
---|
| 307 | void Parameters::SetParam(char* string,int enum_type){
|
---|
| 308 |
|
---|
| 309 | Param* param=NULL;
|
---|
| 310 |
|
---|
| 311 | /*first, figure out if the param has already been created: */
|
---|
| 312 | param=(Param*)this->FindParamObject(enum_type);
|
---|
| 313 |
|
---|
| 314 | if(param) param->SetValue(string); //already exists, just set it.
|
---|
| 315 | else this->AddObject(new StringParam(enum_type,string)); //just add the new parameter.
|
---|
| 316 | }
|
---|
| 317 | /*}}}*/
|
---|
| 318 | /*FUNCTION Parameters::SetParam(char** stringarray,int M, int enum_type);{{{1*/
|
---|
| 319 | void Parameters::SetParam(char** stringarray,int M, int enum_type){
|
---|
| 320 |
|
---|
| 321 | Param* param=NULL;
|
---|
| 322 |
|
---|
| 323 | /*first, figure out if the param has already been created: */
|
---|
| 324 | param=(Param*)this->FindParamObject(enum_type);
|
---|
| 325 |
|
---|
| 326 | if(param) param->SetValue(stringarray,M); //already exists, just set it.
|
---|
| 327 | else this->AddObject(new StringArrayParam(enum_type,stringarray,M)); //just add the new parameter.
|
---|
| 328 | }
|
---|
| 329 | /*}}}*/
|
---|
| 330 | /*FUNCTION Parameters::SetParam(double* doublearray,int M,int enum_type);{{{1*/
|
---|
| 331 | void Parameters::SetParam(double* doublearray,int M, int enum_type){
|
---|
| 332 |
|
---|
| 333 | Param* param=NULL;
|
---|
| 334 |
|
---|
| 335 | /*first, figure out if the param has already been created: */
|
---|
| 336 | param=(Param*)this->FindParamObject(enum_type);
|
---|
| 337 |
|
---|
| 338 | if(param) param->SetValue(doublearray,M); //already exists, just set it.
|
---|
| 339 | else this->AddObject(new DoubleVecParam(enum_type,doublearray,M)); //just add the new parameter.
|
---|
| 340 | }
|
---|
| 341 | /*}}}*/
|
---|
| 342 | /*FUNCTION Parameters::SetParam(double* doublearray,int M,int N, int enum_type);{{{1*/
|
---|
| 343 | void Parameters::SetParam(double* doublearray,int M, int N, int enum_type){
|
---|
| 344 |
|
---|
| 345 | Param* param=NULL;
|
---|
| 346 |
|
---|
| 347 | /*first, figure out if the param has already been created: */
|
---|
| 348 | param=(Param*)this->FindParamObject(enum_type);
|
---|
| 349 |
|
---|
| 350 | if(param) param->SetValue(doublearray,M,N); //already exists, just set it.
|
---|
| 351 | else this->AddObject(new DoubleMatParam(enum_type,doublearray,M,N)); //just add the new parameter.
|
---|
| 352 | }
|
---|
| 353 | /*}}}*/
|
---|
| 354 | /*FUNCTION Parameters::SetParam(Vec vector,int enum_type);{{{1*/
|
---|
| 355 | void Parameters::SetParam(Vec vector,int enum_type){
|
---|
| 356 |
|
---|
| 357 | Param* param=NULL;
|
---|
| 358 |
|
---|
| 359 | /*first, figure out if the param has already been created: */
|
---|
| 360 | param=(Param*)this->FindParamObject(enum_type);
|
---|
| 361 |
|
---|
| 362 | if(param) param->SetValue(vector); //already exists, just set it.
|
---|
| 363 | else this->AddObject(new PetscVecParam(enum_type,vector)); //just add the new parameter.
|
---|
| 364 | }
|
---|
| 365 | /*}}}*/
|
---|
| 366 | /*FUNCTION Parameters::SetParam(Mat matrix,int enum_type);{{{1*/
|
---|
| 367 | void Parameters::SetParam(Mat matrix,int enum_type){
|
---|
| 368 |
|
---|
| 369 | Param* param=NULL;
|
---|
| 370 |
|
---|
| 371 | /*first, figure out if the param has already been created: */
|
---|
| 372 | param=(Param*)this->FindParamObject(enum_type);
|
---|
| 373 |
|
---|
| 374 | if(param) param->SetValue(matrix); //already exists, just set it.
|
---|
| 375 | else this->AddObject(new PetscMatParam(enum_type,matrix)); //just add the new parameter.
|
---|
| 376 | }
|
---|
| 377 | /*}}}*/
|
---|
[4873] | 378 | /*FUNCTION Parameters::SetParam(FILE* fid,int enum_type);{{{1*/
|
---|
| 379 | void Parameters::SetParam(FILE* fid,int enum_type){
|
---|
[4059] | 380 |
|
---|
[4873] | 381 | Param* param=NULL;
|
---|
| 382 |
|
---|
| 383 | /*first, figure out if the param has already been created: */
|
---|
| 384 | param=(Param*)this->FindParamObject(enum_type);
|
---|
| 385 |
|
---|
| 386 | if(param) param->SetValue(fid); //already exists, just set it.
|
---|
| 387 | else this->AddObject(new FileParam(enum_type,fid)); //just add the new parameter.
|
---|
| 388 | }
|
---|
| 389 | /*}}}*/
|
---|
| 390 |
|
---|
[3766] | 391 | /*FUNCTION Parameters::FindParamObject{{{1*/
|
---|
[3702] | 392 | Object* Parameters::FindParamObject(int enum_type){
|
---|
| 393 |
|
---|
| 394 | vector<Object*>::iterator object;
|
---|
| 395 | Param* param=NULL;
|
---|
| 396 |
|
---|
| 397 | for ( object=objects.begin() ; object < objects.end(); object++ ){
|
---|
| 398 |
|
---|
[3766] | 399 | param=(Param*)(*object);
|
---|
| 400 | if(param->EnumType()==enum_type){
|
---|
| 401 | return (*object);
|
---|
[3702] | 402 | }
|
---|
| 403 | }
|
---|
| 404 | return NULL;
|
---|
| 405 | }
|
---|
| 406 | /*}}}*/
|
---|