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

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

trunk: added PentaVertexInputs
File size: 11.5 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){ _assert_(this);
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){ _assert_(this);
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){ _assert_(this);
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){ _assert_(this);
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){ _assert_(this);
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){ _assert_(this);
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){ _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(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){ _assert_(this);
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){ _assert_(this);
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){ _assert_(this);
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){ _assert_(this);
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){ _assert_(this);
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.