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
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
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
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/*}}}*/
[3766]163/*FUNCTION Parameters::FindParam(double** pdoublearray,int* pM,int enum_type){{{1*/
[8376]164void 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]182void 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]200void 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]217void 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]235void 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]253void 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*/
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/*}}}*/
[4873]378/*FUNCTION Parameters::SetParam(FILE* fid,int enum_type);{{{1*/
379void 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]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
[3766]399 param=(Param*)(*object);
400 if(param->EnumType()==enum_type){
401 return (*object);
[3702]402 }
403 }
404 return NULL;
405}
406/*}}}*/
Note: See TracBrowser for help on using the repository browser.