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

Last change on this file since 8263 was 8263, checked in by Mathieu Morlighem, 14 years ago

Error out when parameter is not found (use Exist to check wether it exist or not)
File size: 11.3 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 return;
30}
31/*}}}*/
32/*FUNCTION Parameters::Parameters(int in_enum){{{1*/
33Parameters::Parameters(int in_enum): DataSet(in_enum){
34 //do nothing;
35 return;
36}
37/*}}}*/
38/*FUNCTION Parameters::~Parameters(){{{1*/
39Parameters::~Parameters(){
40 return;
41}
42/*}}}*/
43
44/*Object management*/
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/*}}}*/
58/*FUNCTION Parameters::FindParam(bool* pbool,int enum_type){{{1*/
59void Parameters::FindParam(bool* pbool,int enum_type){
60
61 vector<Object*>::iterator object;
62 Param* param=NULL;
63
64 for ( object=objects.begin() ; object < objects.end(); object++ ){
65
66 param=(Param*)(*object);
67 if(param->EnumType()==enum_type){
68 param->GetParameterValue(pbool);
69 return;
70 }
71 }
72 _error_("could not find parameter %s",EnumToStringx(enum_type));
73}
74/*}}}*/
75/*FUNCTION Parameters::FindParam(int* pinteger,int enum_type){{{1*/
76void Parameters::FindParam(int* pinteger,int enum_type){
77
78 vector<Object*>::iterator object;
79 Param* param=NULL;
80
81 for ( object=objects.begin() ; object < objects.end(); object++ ){
82
83 param=(Param*)(*object);
84 if(param->EnumType()==enum_type){
85 param->GetParameterValue(pinteger);
86 return;
87 }
88 }
89 _error_("could not find parameter %s",EnumToStringx(enum_type));
90}
91/*}}}*/
92/*FUNCTION Parameters::FindParam(double* pscalar, int enum_type){{{1*/
93void Parameters::FindParam(double* pscalar, int enum_type){
94
95 vector<Object*>::iterator object;
96 Param* param=NULL;
97
98 for ( object=objects.begin() ; object < objects.end(); object++ ){
99
100 param=(Param*)(*object);
101 if(param->EnumType()==enum_type){
102 param->GetParameterValue(pscalar);
103 return;
104 }
105 }
106 _error_("could not find parameter %s",EnumToStringx(enum_type));
107}
108/*}}}*/
109/*FUNCTION Parameters::FindParam(char** pstring,int enum_type){{{1*/
110void Parameters::FindParam(char** pstring,int enum_type){
111
112 vector<Object*>::iterator object;
113 Param* param=NULL;
114
115 for ( object=objects.begin() ; object < objects.end(); object++ ){
116
117 param=(Param*)(*object);
118 if(param->EnumType()==enum_type){
119 param->GetParameterValue(pstring);
120 return;
121 }
122 }
123 _error_("could not find parameter %s",EnumToStringx(enum_type));
124
125}
126/*}}}*/
127/*FUNCTION Parameters::FindParam(char*** pstringarray,int* pM,int enum_type){{{1*/
128void Parameters::FindParam(char*** pstringarray,int* pM,int enum_type){
129
130 vector<Object*>::iterator object;
131 Param* param=NULL;
132
133 for ( object=objects.begin() ; object < objects.end(); object++ ){
134
135 param=(Param*)(*object);
136 if(param->EnumType()==enum_type){
137 param->GetParameterValue(pstringarray,pM);
138 return;
139 }
140 }
141 _error_("could not find parameter %s",EnumToStringx(enum_type));
142
143}
144/*}}}*/
145/*FUNCTION Parameters::FindParam(int** pintarray,int* pM,int enum_type){{{1*/
146void Parameters::FindParam(int** pintarray,int* pM, int enum_type){
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);
156 return;
157 }
158 }
159 _error_("could not find parameter %s",EnumToStringx(enum_type));
160
161}
162/*}}}*/
163/*FUNCTION Parameters::FindParam(double** pdoublearray,int* pM,int enum_type){{{1*/
164void Parameters::FindParam(double** pdoublearray,int* pM, int enum_type){
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(pdoublearray,pM);
174 return;
175 }
176 }
177 _error_("could not find parameter %s",EnumToStringx(enum_type));
178
179}
180/*}}}*/
181/*FUNCTION Parameters::FindParam(double** pdoublearray,int* pM, int* pN,int enum_type){{{1*/
182void Parameters::FindParam(double** pdoublearray,int* pM, int* pN,int enum_type){
183
184 vector<Object*>::iterator object;
185 Param* param=NULL;
186
187 for ( object=objects.begin() ; object < objects.end(); object++ ){
188
189 param=(Param*)(*object);
190 if(param->EnumType()==enum_type){
191 param->GetParameterValue(pdoublearray,pM,pN);
192 return;
193 }
194 }
195 _error_("could not find parameter %s",EnumToStringx(enum_type));
196
197}
198/*}}}*/
199/*FUNCTION Parameters::FindParam(double*** parray,int* pM,int** pmdims_array,int** pndims_array,int enum_type){{{1*/
200void Parameters::FindParam(double*** parray,int* pM,int** pmdims_array,int** pndims_array,int enum_type){
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);
210 return;
211 }
212 }
213 _error_("could not find parameter %s",EnumToStringx(enum_type));
214}
215/*}}}*/
216/*FUNCTION Parameters::FindParam(Vec* pvec,int enum_type){{{1*/
217void Parameters::FindParam(Vec* pvec,int enum_type){
218
219 vector<Object*>::iterator object;
220 Param* param=NULL;
221
222 for ( object=objects.begin() ; object < objects.end(); object++ ){
223
224 param=(Param*)(*object);
225 if(param->EnumType()==enum_type){
226 param->GetParameterValue(pvec);
227 return;
228 }
229 }
230 _error_("could not find parameter %s",EnumToStringx(enum_type));
231
232}
233/*}}}*/
234/*FUNCTION Parameters::FindParam(Mat* pmat,int enum_type){{{1*/
235void Parameters::FindParam(Mat* pmat,int enum_type){
236
237 vector<Object*>::iterator object;
238 Param* param=NULL;
239
240 for ( object=objects.begin() ; object < objects.end(); object++ ){
241
242 param=(Param*)(*object);
243 if(param->EnumType()==enum_type){
244 param->GetParameterValue(pmat);
245 return;
246 }
247 }
248 _error_("could not find parameter %s",EnumToStringx(enum_type));
249
250}
251/*}}}*/
252/*FUNCTION Parameters::FindParam(FILE** pfid,int enum_type){{{1*/
253void Parameters::FindParam(FILE** pfid,int enum_type){
254
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);
263 return;
264 }
265 }
266 _error_("could not find parameter %s",EnumToStringx(enum_type));
267}
268/*}}}*/
269
270/*FUNCTION Parameters::SetParam(bool boolean,int enum_type);{{{1*/
271void 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*/
283void 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*/
295void 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*/
307void 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*/
319void 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*/
331void 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*/
343void 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*/
355void 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*/
367void 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/*}}}*/
378/*FUNCTION Parameters::SetParam(FILE* fid,int enum_type);{{{1*/
379void Parameters::SetParam(FILE* fid,int enum_type){
380
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
391/*FUNCTION Parameters::FindParamObject{{{1*/
392Object* 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
399 param=(Param*)(*object);
400 if(param->EnumType()==enum_type){
401 return (*object);
402 }
403 }
404 return NULL;
405}
406/*}}}*/
Note: See TracBrowser for help on using the repository browser.