source: issm/trunk/src/c/Container/Parameters.cpp@ 9356

Last change on this file since 9356 was 9356, checked in by Eric.Larour, 14 years ago

Major rewrite of the code so that IoModel now has a parameters dataset, which gets
loaded with all the int,char and double objects in the input file.
This is a lot more flexible, as anyone can add a field to the model, and it will
automatically appear in the IoModel parameters dataset.

Not debugged with respect to nightly runs yet. Trying to get the whole change finished.

File size: 13.2 KB
RevLine 
[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
[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
23using namespace std;
24/*}}}*/
25
26/*Object constructors and destructor*/
[3766]27/*FUNCTION Parameters::Parameters(){{{1*/
[3702]28Parameters::Parameters(){
29 return;
30}
31/*}}}*/
[3766]32/*FUNCTION Parameters::Parameters(int in_enum){{{1*/
[3702]33Parameters::Parameters(int in_enum): DataSet(in_enum){
34 //do nothing;
35 return;
36}
37/*}}}*/
[3766]38/*FUNCTION Parameters::~Parameters(){{{1*/
[3702]39Parameters::~Parameters(){
40 return;
41}
42/*}}}*/
43
44/*Object management*/
[8263]45/*FUNCTION Parameters::Exist{{{1*/
46bool 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]59void 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]76void 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]93void 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]110void 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]128void 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]146void 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/*}}}*/
[8600]163/*FUNCTION Parameters::FindParam(int** pintarray,int* pM,int* pN,int enum_type){{{1*/
164void Parameters::FindParam(int** pintarray,int* pM,int *pN,int enum_type){ _assert_(this);
165
166 vector<Object*>::iterator object;
167 Param* param=NULL;
168
169 for ( object=objects.begin() ; object < objects.end(); object++ ){
170
171 param=(Param*)(*object);
172 if(param->EnumType()==enum_type){
173 param->GetParameterValue(pintarray,pM,pN);
174 return;
175 }
176 }
177 _error_("could not find parameter %s",EnumToStringx(enum_type));
178
179}
180/*}}}*/
[3766]181/*FUNCTION Parameters::FindParam(double** pdoublearray,int* pM,int enum_type){{{1*/
[8376]182void Parameters::FindParam(double** pdoublearray,int* pM, 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);
[8263]192 return;
[3702]193 }
194 }
[8263]195 _error_("could not find parameter %s",EnumToStringx(enum_type));
[3702]196
197}
198/*}}}*/
[3766]199/*FUNCTION Parameters::FindParam(double** pdoublearray,int* pM, int* pN,int enum_type){{{1*/
[8376]200void Parameters::FindParam(double** pdoublearray,int* pM, int* pN,int enum_type){ _assert_(this);
[8263]201
[3702]202 vector<Object*>::iterator object;
203 Param* param=NULL;
204
205 for ( object=objects.begin() ; object < objects.end(); object++ ){
206
[3766]207 param=(Param*)(*object);
208 if(param->EnumType()==enum_type){
209 param->GetParameterValue(pdoublearray,pM,pN);
[8263]210 return;
[3702]211 }
212 }
[8263]213 _error_("could not find parameter %s",EnumToStringx(enum_type));
[3702]214
215}
216/*}}}*/
[4855]217/*FUNCTION Parameters::FindParam(double*** parray,int* pM,int** pmdims_array,int** pndims_array,int enum_type){{{1*/
[8376]218void Parameters::FindParam(double*** parray,int* pM,int** pmdims_array,int** pndims_array,int enum_type){ _assert_(this);
[4855]219
220 vector<Object*>::iterator object;
221 Param* param=NULL;
222
223 for ( object=objects.begin() ; object < objects.end(); object++ ){
224
225 param=(Param*)(*object);
226 if(param->EnumType()==enum_type){
227 param->GetParameterValue(parray,pM,pmdims_array,pndims_array);
[8263]228 return;
[4855]229 }
230 }
[8263]231 _error_("could not find parameter %s",EnumToStringx(enum_type));
[4855]232}
233/*}}}*/
[3766]234/*FUNCTION Parameters::FindParam(Vec* pvec,int enum_type){{{1*/
[8376]235void Parameters::FindParam(Vec* pvec,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(pvec);
[8263]245 return;
[3702]246 }
247 }
[8263]248 _error_("could not find parameter %s",EnumToStringx(enum_type));
[3702]249
250}
251/*}}}*/
[4059]252/*FUNCTION Parameters::FindParam(Mat* pmat,int enum_type){{{1*/
[8376]253void Parameters::FindParam(Mat* pmat,int enum_type){ _assert_(this);
[3702]254
255 vector<Object*>::iterator object;
256 Param* param=NULL;
257
258 for ( object=objects.begin() ; object < objects.end(); object++ ){
259
[3766]260 param=(Param*)(*object);
261 if(param->EnumType()==enum_type){
262 param->GetParameterValue(pmat);
[8263]263 return;
[3702]264 }
265 }
[8263]266 _error_("could not find parameter %s",EnumToStringx(enum_type));
[3702]267
268}
269/*}}}*/
[4873]270/*FUNCTION Parameters::FindParam(FILE** pfid,int enum_type){{{1*/
[8376]271void Parameters::FindParam(FILE** pfid,int enum_type){ _assert_(this);
[4059]272
[4873]273 vector<Object*>::iterator object;
274 Param* param=NULL;
275
276 for ( object=objects.begin() ; object < objects.end(); object++ ){
277
278 param=(Param*)(*object);
279 if(param->EnumType()==enum_type){
280 param->GetParameterValue(pfid);
[8263]281 return;
[4873]282 }
283 }
[8263]284 _error_("could not find parameter %s",EnumToStringx(enum_type));
[4873]285}
286/*}}}*/
287
[4059]288/*FUNCTION Parameters::SetParam(bool boolean,int enum_type);{{{1*/
289void Parameters::SetParam(bool boolean,int enum_type){
290
291 Param* param=NULL;
292
293 /*first, figure out if the param has already been created: */
294 param=(Param*)this->FindParamObject(enum_type);
295
296 if(param) param->SetValue(boolean); //already exists, just set it.
297 else this->AddObject(new BoolParam(enum_type,boolean)); //just add the new parameter.
298}
299/*}}}*/
300/*FUNCTION Parameters::SetParam(int integer,int enum_type);{{{1*/
301void Parameters::SetParam(int integer,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(integer); //already exists, just set it.
309 else this->AddObject(new IntParam(enum_type,integer)); //just add the new parameter.
310}
311/*}}}*/
312/*FUNCTION Parameters::SetParam(double scalar,int enum_type);{{{1*/
313void Parameters::SetParam(double scalar,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(scalar); //already exists, just set it.
321 else this->AddObject(new DoubleParam(enum_type,scalar)); //just add the new parameter.
322}
323/*}}}*/
324/*FUNCTION Parameters::SetParam(char* string,int enum_type);{{{1*/
325void Parameters::SetParam(char* string,int enum_type){
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(string); //already exists, just set it.
333 else this->AddObject(new StringParam(enum_type,string)); //just add the new parameter.
334}
335/*}}}*/
336/*FUNCTION Parameters::SetParam(char** stringarray,int M, int enum_type);{{{1*/
337void Parameters::SetParam(char** stringarray,int M, 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(stringarray,M); //already exists, just set it.
345 else this->AddObject(new StringArrayParam(enum_type,stringarray,M)); //just add the new parameter.
346}
347/*}}}*/
348/*FUNCTION Parameters::SetParam(double* doublearray,int M,int enum_type);{{{1*/
349void Parameters::SetParam(double* doublearray,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(doublearray,M); //already exists, just set it.
357 else this->AddObject(new DoubleVecParam(enum_type,doublearray,M)); //just add the new parameter.
358}
359/*}}}*/
360/*FUNCTION Parameters::SetParam(double* doublearray,int M,int N, int enum_type);{{{1*/
361void Parameters::SetParam(double* doublearray,int M, int N, int enum_type){
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
368 if(param) param->SetValue(doublearray,M,N); //already exists, just set it.
369 else this->AddObject(new DoubleMatParam(enum_type,doublearray,M,N)); //just add the new parameter.
370}
371/*}}}*/
[8600]372/*FUNCTION Parameters::SetParam(int* intarray,int M,int enum_type);{{{1*/
373void Parameters::SetParam(int* intarray,int M, int enum_type){
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
380 if(param) param->SetValue(intarray,M); //already exists, just set it.
381 else this->AddObject(new IntVecParam(enum_type,intarray,M)); //just add the new parameter.
382}
383/*}}}*/
384/*FUNCTION Parameters::SetParam(int* intarray,int M,int N, int enum_type);{{{1*/
385void Parameters::SetParam(int* intarray,int M, int N, 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,N); //already exists, just set it.
393 else this->AddObject(new IntMatParam(enum_type,intarray,M,N)); //just add the new parameter.
394}
395/*}}}*/
[4059]396/*FUNCTION Parameters::SetParam(Vec vector,int enum_type);{{{1*/
397void Parameters::SetParam(Vec vector,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(vector); //already exists, just set it.
405 else this->AddObject(new PetscVecParam(enum_type,vector)); //just add the new parameter.
406}
407/*}}}*/
408/*FUNCTION Parameters::SetParam(Mat matrix,int enum_type);{{{1*/
409void Parameters::SetParam(Mat matrix,int enum_type){
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(matrix); //already exists, just set it.
417 else this->AddObject(new PetscMatParam(enum_type,matrix)); //just add the new parameter.
418}
419/*}}}*/
[4873]420/*FUNCTION Parameters::SetParam(FILE* fid,int enum_type);{{{1*/
421void Parameters::SetParam(FILE* fid,int enum_type){
[4059]422
[4873]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(fid); //already exists, just set it.
429 else this->AddObject(new FileParam(enum_type,fid)); //just add the new parameter.
430}
431/*}}}*/
[9356]432/*FUNCTION Parameters::UnitConversion(int direction_enum);{{{1*/
433void Parameters::UnitConversion(int direction_enum){
[4873]434
[9356]435 vector<Object*>::iterator object;
436 Param* param=NULL;
437
438 for ( object=objects.begin() ; object < objects.end(); object++ ){
439 param=(Param*)(*object);
440 param->UnitConversion(direction_enum);
441 }
442
443}
444/*}}}*/
445
[3766]446/*FUNCTION Parameters::FindParamObject{{{1*/
[3702]447Object* Parameters::FindParamObject(int enum_type){
448
449 vector<Object*>::iterator object;
450 Param* param=NULL;
451
452 for ( object=objects.begin() ; object < objects.end(); object++ ){
453
[3766]454 param=(Param*)(*object);
455 if(param->EnumType()==enum_type){
456 return (*object);
[3702]457 }
458 }
459 return NULL;
460}
461/*}}}*/
Note: See TracBrowser for help on using the repository browser.