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

Last change on this file since 10522 was 10522, checked in by Mathieu Morlighem, 13 years ago

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