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

Last change on this file since 13395 was 13395, checked in by Mathieu Morlighem, 12 years ago

merged trunk-jpl and trunk for revision 13393

File size: 13.8 KB
RevLine 
[3702]1/*
2 * \file Parameters.c
3 * \brief: implementation of the Parameters class, derived from DataSet class
4 */
5
[12706]6/*Headers: {{{*/
[3702]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*/
[12706]27/*FUNCTION Parameters::Parameters(){{{*/
[3702]28Parameters::Parameters(){
[10522]29 enum_type=ParametersEnum;
[3702]30 return;
31}
32/*}}}*/
[12706]33/*FUNCTION Parameters::~Parameters(){{{*/
[3702]34Parameters::~Parameters(){
35 return;
36}
37/*}}}*/
38
39/*Object management*/
[12706]40/*FUNCTION Parameters::Exist{{{*/
[8263]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);
[9883]48 if(param->InstanceEnum()==enum_type) return true;
[8263]49 }
50 return false;
51}
52/*}}}*/
[12706]53/*FUNCTION Parameters::FindParam(bool* pbool,int enum_type){{{*/
[8376]54void Parameters::FindParam(bool* pbool,int enum_type){ _assert_(this);
[3702]55
56 vector<Object*>::iterator object;
57 Param* param=NULL;
58
59 for ( object=objects.begin() ; object < objects.end(); object++ ){
60
[3766]61 param=(Param*)(*object);
[9883]62 if(param->InstanceEnum()==enum_type){
[3766]63 param->GetParameterValue(pbool);
[8263]64 return;
[3702]65 }
66 }
[13395]67 _error_("could not find parameter " << EnumToStringx(enum_type));
[3702]68}
69/*}}}*/
[12706]70/*FUNCTION Parameters::FindParam(int* pinteger,int enum_type){{{*/
[8376]71void Parameters::FindParam(int* pinteger,int enum_type){ _assert_(this);
[3702]72
73 vector<Object*>::iterator object;
74 Param* param=NULL;
75
76 for ( object=objects.begin() ; object < objects.end(); object++ ){
77
[3766]78 param=(Param*)(*object);
[9883]79 if(param->InstanceEnum()==enum_type){
[3766]80 param->GetParameterValue(pinteger);
[8263]81 return;
[3702]82 }
83 }
[13395]84 _error_("could not find parameter " << EnumToStringx(enum_type));
[3702]85}
86/*}}}*/
[12706]87/*FUNCTION Parameters::FindParam(IssmDouble* pscalar, int enum_type){{{*/
88void Parameters::FindParam(IssmDouble* pscalar, int enum_type){ _assert_(this);
[3732]89
90 vector<Object*>::iterator object;
91 Param* param=NULL;
92
93 for ( object=objects.begin() ; object < objects.end(); object++ ){
94
[3766]95 param=(Param*)(*object);
[9883]96 if(param->InstanceEnum()==enum_type){
[3766]97 param->GetParameterValue(pscalar);
[8263]98 return;
[3732]99 }
100 }
[13395]101 _error_("could not find parameter " << EnumToStringx(enum_type));
[3732]102}
103/*}}}*/
[13395]104/*FUNCTION Parameters::FindParam(IssmDouble* pscalar, int enum_type,IssmDouble time){{{*/
105void Parameters::FindParam(IssmDouble* pscalar, int enum_type,IssmDouble time){ _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(pscalar,time);
115 return;
116 }
117 }
118 _error_("could not find parameter " << EnumToStringx(enum_type));
119}
120/*}}}*/
[12706]121/*FUNCTION Parameters::FindParam(char** pstring,int enum_type){{{*/
[8376]122void Parameters::FindParam(char** pstring,int enum_type){ _assert_(this);
[3702]123
124 vector<Object*>::iterator object;
125 Param* param=NULL;
126
127 for ( object=objects.begin() ; object < objects.end(); object++ ){
128
[3766]129 param=(Param*)(*object);
[9883]130 if(param->InstanceEnum()==enum_type){
[3766]131 param->GetParameterValue(pstring);
[8263]132 return;
[3702]133 }
134 }
[13395]135 _error_("could not find parameter " << EnumToStringx(enum_type));
[3702]136
137}
138/*}}}*/
[12706]139/*FUNCTION Parameters::FindParam(char*** pstringarray,int* pM,int enum_type){{{*/
[8376]140void Parameters::FindParam(char*** pstringarray,int* pM,int enum_type){ _assert_(this);
[3702]141
142 vector<Object*>::iterator object;
143 Param* param=NULL;
144
145 for ( object=objects.begin() ; object < objects.end(); object++ ){
146
[3766]147 param=(Param*)(*object);
[9883]148 if(param->InstanceEnum()==enum_type){
[3766]149 param->GetParameterValue(pstringarray,pM);
[8263]150 return;
[3702]151 }
152 }
[13395]153 _error_("could not find parameter " << EnumToStringx(enum_type));
[3702]154
155}
156/*}}}*/
[12706]157/*FUNCTION Parameters::FindParam(int** pintarray,int* pM,int enum_type){{{*/
[8376]158void Parameters::FindParam(int** pintarray,int* pM, int enum_type){ _assert_(this);
[6213]159
160 vector<Object*>::iterator object;
161 Param* param=NULL;
162
163 for ( object=objects.begin() ; object < objects.end(); object++ ){
164
165 param=(Param*)(*object);
[9883]166 if(param->InstanceEnum()==enum_type){
[6213]167 param->GetParameterValue(pintarray,pM);
[8263]168 return;
[6213]169 }
170 }
[13395]171 _error_("could not find parameter " << EnumToStringx(enum_type));
[6213]172
173}
174/*}}}*/
[12706]175/*FUNCTION Parameters::FindParam(int** pintarray,int* pM,int* pN,int enum_type){{{*/
[8600]176void Parameters::FindParam(int** pintarray,int* pM,int *pN,int enum_type){ _assert_(this);
177
178 vector<Object*>::iterator object;
179 Param* param=NULL;
180
181 for ( object=objects.begin() ; object < objects.end(); object++ ){
182
183 param=(Param*)(*object);
[9883]184 if(param->InstanceEnum()==enum_type){
[8600]185 param->GetParameterValue(pintarray,pM,pN);
186 return;
187 }
188 }
[13395]189 _error_("could not find parameter " << EnumToStringx(enum_type));
[8600]190
191}
192/*}}}*/
[12706]193/*FUNCTION Parameters::FindParam(IssmDouble** pIssmDoublearray,int* pM,int enum_type){{{*/
194void Parameters::FindParam(IssmDouble** pIssmDoublearray,int* pM, int enum_type){ _assert_(this);
[8263]195
[3702]196 vector<Object*>::iterator object;
197 Param* param=NULL;
198
199 for ( object=objects.begin() ; object < objects.end(); object++ ){
200
[3766]201 param=(Param*)(*object);
[9883]202 if(param->InstanceEnum()==enum_type){
[12706]203 param->GetParameterValue(pIssmDoublearray,pM);
[8263]204 return;
[3702]205 }
206 }
[13395]207 _error_("could not find parameter " << EnumToStringx(enum_type));
[3702]208
209}
210/*}}}*/
[12706]211/*FUNCTION Parameters::FindParam(IssmDouble** pIssmDoublearray,int* pM, int* pN,int enum_type){{{*/
212void Parameters::FindParam(IssmDouble** pIssmDoublearray,int* pM, int* pN,int enum_type){ _assert_(this);
[8263]213
[3702]214 vector<Object*>::iterator object;
215 Param* param=NULL;
216
217 for ( object=objects.begin() ; object < objects.end(); object++ ){
218
[3766]219 param=(Param*)(*object);
[9883]220 if(param->InstanceEnum()==enum_type){
[12706]221 param->GetParameterValue(pIssmDoublearray,pM,pN);
[8263]222 return;
[3702]223 }
224 }
[13395]225 _error_("could not find parameter " << EnumToStringx(enum_type));
[3702]226
227}
228/*}}}*/
[12706]229/*FUNCTION Parameters::FindParam(IssmDouble*** parray,int* pM,int** pmdims_array,int** pndims_array,int enum_type){{{*/
230void Parameters::FindParam(IssmDouble*** parray,int* pM,int** pmdims_array,int** pndims_array,int enum_type){ _assert_(this);
[4855]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);
[9883]238 if(param->InstanceEnum()==enum_type){
[4855]239 param->GetParameterValue(parray,pM,pmdims_array,pndims_array);
[8263]240 return;
[4855]241 }
242 }
[13395]243 _error_("could not find parameter " << EnumToStringx(enum_type));
[4855]244}
245/*}}}*/
[13395]246/*FUNCTION Parameters::FindParam(Vector<IssmDouble>** pvec,int enum_type){{{*/
247void Parameters::FindParam(Vector<IssmDouble>** pvec,int enum_type){ _assert_(this);
[3702]248
249 vector<Object*>::iterator object;
250 Param* param=NULL;
251
252 for ( object=objects.begin() ; object < objects.end(); object++ ){
253
[3766]254 param=(Param*)(*object);
[9883]255 if(param->InstanceEnum()==enum_type){
[3766]256 param->GetParameterValue(pvec);
[8263]257 return;
[3702]258 }
259 }
[13395]260 _error_("could not find parameter " << EnumToStringx(enum_type));
[3702]261
262}
263/*}}}*/
[13395]264/*FUNCTION Parameters::FindParam(Matrix<IssmDouble>** pmat,int enum_type){{{*/
265void Parameters::FindParam(Matrix<IssmDouble>** pmat,int enum_type){ _assert_(this);
[3702]266
267 vector<Object*>::iterator object;
268 Param* param=NULL;
269
270 for ( object=objects.begin() ; object < objects.end(); object++ ){
271
[3766]272 param=(Param*)(*object);
[9883]273 if(param->InstanceEnum()==enum_type){
[3766]274 param->GetParameterValue(pmat);
[8263]275 return;
[3702]276 }
277 }
[13395]278 _error_("could not find parameter " << EnumToStringx(enum_type));
[3702]279
280}
281/*}}}*/
[12706]282/*FUNCTION Parameters::FindParam(FILE** pfid,int enum_type){{{*/
[8376]283void Parameters::FindParam(FILE** pfid,int enum_type){ _assert_(this);
[4059]284
[4873]285 vector<Object*>::iterator object;
286 Param* param=NULL;
287
288 for ( object=objects.begin() ; object < objects.end(); object++ ){
289
290 param=(Param*)(*object);
[9883]291 if(param->InstanceEnum()==enum_type){
[4873]292 param->GetParameterValue(pfid);
[8263]293 return;
[4873]294 }
295 }
[13395]296 _error_("could not find parameter " << EnumToStringx(enum_type));
[4873]297}
298/*}}}*/
299
[12706]300/*FUNCTION Parameters::SetParam(bool boolean,int enum_type);{{{*/
[4059]301void Parameters::SetParam(bool boolean,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(boolean); //already exists, just set it.
309 else this->AddObject(new BoolParam(enum_type,boolean)); //just add the new parameter.
310}
311/*}}}*/
[12706]312/*FUNCTION Parameters::SetParam(int integer,int enum_type);{{{*/
[4059]313void Parameters::SetParam(int integer,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(integer); //already exists, just set it.
321 else this->AddObject(new IntParam(enum_type,integer)); //just add the new parameter.
322}
323/*}}}*/
[12706]324/*FUNCTION Parameters::SetParam(IssmDouble scalar,int enum_type);{{{*/
325void Parameters::SetParam(IssmDouble scalar,int enum_type){
[4059]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(scalar); //already exists, just set it.
333 else this->AddObject(new DoubleParam(enum_type,scalar)); //just add the new parameter.
334}
335/*}}}*/
[12706]336/*FUNCTION Parameters::SetParam(char* string,int enum_type);{{{*/
[4059]337void Parameters::SetParam(char* string,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(string); //already exists, just set it.
345 else this->AddObject(new StringParam(enum_type,string)); //just add the new parameter.
346}
347/*}}}*/
[12706]348/*FUNCTION Parameters::SetParam(char** stringarray,int M, int enum_type);{{{*/
[4059]349void Parameters::SetParam(char** stringarray,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(stringarray,M); //already exists, just set it.
357 else this->AddObject(new StringArrayParam(enum_type,stringarray,M)); //just add the new parameter.
358}
359/*}}}*/
[12706]360/*FUNCTION Parameters::SetParam(IssmDouble* IssmDoublearray,int M,int enum_type);{{{*/
361void Parameters::SetParam(IssmDouble* IssmDoublearray,int M, int enum_type){
[4059]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
[12706]368 if(param) param->SetValue(IssmDoublearray,M); //already exists, just set it.
369 else this->AddObject(new DoubleVecParam(enum_type,IssmDoublearray,M)); //just add the new parameter.
[4059]370}
371/*}}}*/
[12706]372/*FUNCTION Parameters::SetParam(IssmDouble* IssmDoublearray,int M,int N, int enum_type);{{{*/
373void Parameters::SetParam(IssmDouble* IssmDoublearray,int M, int N, int enum_type){
[4059]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
[12706]380 if(param) param->SetValue(IssmDoublearray,M,N); //already exists, just set it.
381 else this->AddObject(new DoubleMatParam(enum_type,IssmDoublearray,M,N)); //just add the new parameter.
[4059]382}
383/*}}}*/
[12706]384/*FUNCTION Parameters::SetParam(int* intarray,int M,int enum_type);{{{*/
[8600]385void Parameters::SetParam(int* intarray,int M, 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); //already exists, just set it.
393 else this->AddObject(new IntVecParam(enum_type,intarray,M)); //just add the new parameter.
394}
395/*}}}*/
[12706]396/*FUNCTION Parameters::SetParam(int* intarray,int M,int N, int enum_type);{{{*/
[8600]397void Parameters::SetParam(int* intarray,int M, int N, 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(intarray,M,N); //already exists, just set it.
405 else this->AddObject(new IntMatParam(enum_type,intarray,M,N)); //just add the new parameter.
406}
407/*}}}*/
[13395]408/*FUNCTION Parameters::SetParam(Vector<IssmDouble>* vector,int enum_type);{{{*/
409void Parameters::SetParam(Vector<IssmDouble>* vector,int enum_type){
[4059]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(vector); //already exists, just set it.
[11995]417 else this->AddObject(new VectorParam(enum_type,vector)); //just add the new parameter.
[4059]418}
419/*}}}*/
[13395]420/*FUNCTION Parameters::SetParam(Matrix<IssmDouble>* matrix,int enum_type);{{{*/
421void Parameters::SetParam(Matrix<IssmDouble>* matrix,int enum_type){
[4059]422
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(matrix); //already exists, just set it.
[11995]429 else this->AddObject(new MatrixParam(enum_type,matrix)); //just add the new parameter.
[4059]430}
431/*}}}*/
[12706]432/*FUNCTION Parameters::SetParam(FILE* fid,int enum_type);{{{*/
[4873]433void Parameters::SetParam(FILE* fid,int enum_type){
[4059]434
[4873]435 Param* param=NULL;
436
437 /*first, figure out if the param has already been created: */
438 param=(Param*)this->FindParamObject(enum_type);
439
440 if(param) param->SetValue(fid); //already exists, just set it.
441 else this->AddObject(new FileParam(enum_type,fid)); //just add the new parameter.
442}
443/*}}}*/
[12706]444/*FUNCTION Parameters::UnitConversion(int direction_enum);{{{*/
[9356]445void Parameters::UnitConversion(int direction_enum){
[4873]446
[9356]447 vector<Object*>::iterator object;
448 Param* param=NULL;
449
450 for ( object=objects.begin() ; object < objects.end(); object++ ){
451 param=(Param*)(*object);
452 param->UnitConversion(direction_enum);
453 }
454
455}
456/*}}}*/
457
[12706]458/*FUNCTION Parameters::FindParamObject{{{*/
[3702]459Object* Parameters::FindParamObject(int enum_type){
460
461 vector<Object*>::iterator object;
462 Param* param=NULL;
463
464 for ( object=objects.begin() ; object < objects.end(); object++ ){
465
[3766]466 param=(Param*)(*object);
[9883]467 if(param->InstanceEnum()==enum_type){
[3766]468 return (*object);
[3702]469 }
470 }
471 return NULL;
472}
473/*}}}*/
Note: See TracBrowser for help on using the repository browser.