source: issm/trunk-jpl/src/c/Container/Inputs.cpp@ 12493

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

replaced all _error_ to _error2_
File size: 9.9 KB
Line 
1/*
2 * \file Inputs.c
3 * \brief: implementation of the Inputs class, derived from DataSet class
4 */
5
6/*Headers: {{{*/
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 Inputs::Inputs(){{{*/
28Inputs::Inputs(){
29 return;
30}
31/*}}}*/
32/*FUNCTION Inputs::~Inputs(){{{*/
33Inputs::~Inputs(){
34 return;
35}
36/*}}}*/
37
38/*Object management*/
39/*FUNCTION Inputs::GetInputValue(bool* pvalue,int enum-type){{{*/
40void Inputs::GetInputValue(bool* pvalue,int enum_type){
41
42 vector<Object*>::iterator object;
43 Input* input=NULL;
44 bool found=false;
45
46 /*Go through inputs and check whether any input with the same name is already in: */
47 for ( object=objects.begin() ; object < objects.end(); object++ ){
48
49 input=(Input*)(*object);
50 if (input->InstanceEnum()==enum_type){
51 found=true;
52 break;
53 }
54 }
55
56 if (!found){
57 /*we could not find an input with the correct enum type. No defaults values were provided,
58 * error out: */
59 _error2_("could not find input with enum type " << enum_type << " (" << EnumToStringx(enum_type) << ")");
60 }
61
62 /*Ok, we have an input if we made it here, request the input to return the value: */
63 input->GetInputValue(pvalue);
64
65}
66/*}}}*/
67/*FUNCTION Inputs::GetInputValue(int* pvalue,int enum-type){{{*/
68void Inputs::GetInputValue(int* pvalue,int enum_type){
69
70 vector<Object*>::iterator object;
71 Input* input=NULL;
72 bool found=false;
73
74 /*Go through inputs and check whether any input with the same name is already in: */
75 for ( object=objects.begin() ; object < objects.end(); object++ ){
76
77 input=(Input*)(*object);
78 if (input->InstanceEnum()==enum_type){
79 found=true;
80 break;
81 }
82 }
83
84 if (!found){
85 /*we could not find an input with the correct enum type. No defaults values were provided,
86 * error out: */
87 _error2_("could not find input with enum type " << enum_type << " (" << EnumToStringx(enum_type) << ")");
88 }
89
90 /*Ok, we have an input if we made it here, request the input to return the value: */
91 input->GetInputValue(pvalue);
92
93}
94/*}}}*/
95/*FUNCTION Inputs::GetInputValue(IssmDouble* pvalue,int enum-type){{{*/
96void Inputs::GetInputValue(IssmDouble* pvalue,int enum_type){
97
98 vector<Object*>::iterator object;
99 Input* input=NULL;
100 bool found=false;
101
102 /*Go through inputs and check whether any input with the same name is already in: */
103 for ( object=objects.begin() ; object < objects.end(); object++ ){
104
105 input=(Input*)(*object);
106 if (input->InstanceEnum()==enum_type){
107 found=true;
108 break;
109 }
110 }
111
112 if (!found){
113 /*we could not find an input with the correct enum type. No defaults values were provided,
114 * error out: */
115 _error2_("could not find input with enum type " << enum_type << " (" << EnumToStringx(enum_type) << ")");
116 }
117
118 /*Ok, we have an input if we made it here, request the input to return the value: */
119 input->GetInputValue(pvalue);
120
121}
122/*}}}*/
123/*FUNCTION Inputs::GetInputAverage{{{*/
124void Inputs::GetInputAverage(IssmDouble* pvalue,int enum_type){
125
126 vector<Object*>::iterator object;
127 Input* input=NULL;
128 bool found=false;
129
130 /*Go through inputs and check whether any input with the same name is already in: */
131 for ( object=objects.begin() ; object < objects.end(); object++ ){
132
133 input=(Input*)(*object);
134 if (input->InstanceEnum()==enum_type){
135 found=true;
136 break;
137 }
138 }
139
140 if (!found){
141 /*we could not find an input with the correct enum type. No defaults values were provided,
142 * error out: */
143 _error2_("could not find input with enum type " << enum_type << " (" << EnumToStringx(enum_type) << ")");
144 }
145
146 /*Ok, we have an input if we made it here, request the input to return the value: */
147 input->GetInputAverage(pvalue);
148
149}
150/*}}}*/
151/*FUNCTION Inputs::AddInput{{{*/
152int Inputs::AddInput(Input* in_input){
153
154 /*First, go through dataset of inputs and check whether any input
155 * with the same name is already in. If so, erase the corresponding
156 * object before adding this new one: */
157 vector<Object*>::iterator object;
158 Input* input=NULL;
159
160 /*In debugging mode, check that the input is not a NULL pointer*/
161 _assert_(in_input);
162
163 for ( object=objects.begin() ; object < objects.end(); object++ ){
164
165 input=(Input*)(*object);
166
167 if (input->InstanceEnum()==in_input->InstanceEnum()){
168 this->DeleteObject(input);
169 break;
170 }
171 }
172 this->AddObject(in_input);
173
174 return 1;
175}
176/*}}}*/
177/*FUNCTION Inputs::ChangeEnum{{{*/
178void Inputs::ChangeEnum(int oldenumtype,int newenumtype){
179
180 /*Go through dataset of inputs and look for input with
181 * same enum as input enum, once found, just change its name */
182 vector<Object*>::iterator object;
183 Input* input=NULL;
184
185 /*Delete existing input of newenumtype if it exists*/
186 for ( object=objects.begin() ; object < objects.end(); object++ ){
187 input=(Input*)(*object);
188
189 if (input->InstanceEnum()==newenumtype){
190 this->DeleteObject(input);
191 break;
192 }
193 }
194
195 /*Change enum_type of input of oldenumtype*/
196 for ( object=objects.begin() ; object < objects.end(); object++ ){
197
198 input=(Input*)(*object);
199
200 if (input->InstanceEnum()==oldenumtype){
201 input->ChangeEnum(newenumtype);
202 break;
203 }
204 }
205}
206/*}}}*/
207/*FUNCTION Inputs::ConstrainMin{{{*/
208void Inputs::ConstrainMin(int constrain_enum, IssmDouble minimum){
209
210 Input* constrain_input=NULL;
211 /*Find x and y inputs: */
212 constrain_input=(Input*)this->GetInput(constrain_enum);
213
214 /*some checks: */
215 if(!constrain_input) _error2_(" input " << EnumToStringx(constrain_enum) << " could not be found!");
216
217 /*Apply ContrainMin: */
218 constrain_input->ConstrainMin(minimum);
219}
220/*}}}*/
221/*FUNCTION Inputs::InfinityNorm{{{*/
222IssmDouble Inputs::InfinityNorm(int enumtype){
223
224 /*Output*/
225 IssmDouble norm;
226
227 /*Get input*/
228 Input* input=(Input*)this->GetInput(enumtype);
229
230 /*Apply ContrainMin: */
231 if (input){
232 norm=input->InfinityNorm();
233 }
234 else{
235 norm=0;
236 }
237
238 /*Return output*/
239 return norm;
240}
241/*}}}*/
242/*FUNCTION Inputs::Max{{{*/
243IssmDouble Inputs::Max(int enumtype){
244
245 /*Output*/
246 IssmDouble max;
247
248 /*Get input*/
249 Input* input=(Input*)this->GetInput(enumtype);
250
251 /*Apply ContrainMin: */
252 if (input){
253 max=input->Max();
254 }
255 else{
256 _error2_("Input " << EnumToStringx(enumtype) << " not found");
257 }
258
259 /*Return output*/
260 return max;
261}
262/*}}}*/
263/*FUNCTION Inputs::MaxAbs{{{*/
264IssmDouble Inputs::MaxAbs(int enumtype){
265
266 /*Output*/
267 IssmDouble max;
268
269 /*Get input*/
270 Input* input=(Input*)this->GetInput(enumtype);
271
272 /*Apply ContrainMin: */
273 if (input){
274 max=input->MaxAbs();
275 }
276 else{
277 _error2_("Input " << EnumToStringx(enumtype) << " not found");
278 }
279
280 /*Return output*/
281 return max;
282}
283/*}}}*/
284/*FUNCTION Inputs::Min{{{*/
285IssmDouble Inputs::Min(int enumtype){
286
287 /*Output*/
288 IssmDouble min;
289
290 /*Get input*/
291 Input* input=(Input*)this->GetInput(enumtype);
292
293 /*Apply ContrainMin: */
294 if (input){
295 min=input->Min();
296 }
297 else{
298 _error2_("Input " << EnumToStringx(enumtype) << " not found");
299 }
300
301 /*Return output*/
302 return min;
303}
304/*}}}*/
305/*FUNCTION Inputs::MinAbs{{{*/
306IssmDouble Inputs::MinAbs(int enumtype){
307
308 /*Output*/
309 IssmDouble min;
310
311 /*Get input*/
312 Input* input=(Input*)this->GetInput(enumtype);
313
314 /*Apply ContrainMin: */
315 if (input){
316 min=input->MinAbs();
317 }
318 else{
319 _error2_("Input " << EnumToStringx(enumtype) << " not found");
320 }
321
322 /*Return output*/
323 return min;
324}
325/*}}}*/
326/*FUNCTION Inputs::GetInput{{{*/
327Input* Inputs::GetInput(int enum_name){
328
329 vector<Object*>::iterator object;
330 Input* input=NULL;
331
332 for ( object=objects.begin() ; object < objects.end(); object++ ){
333
334 input=(Input*)(*object);
335
336 if (input->InstanceEnum()==enum_name){
337 return input;
338 }
339 }
340 return NULL;
341}
342/*}}}*/
343/*FUNCTION Inputs::DeleteInput{{{*/
344int Inputs::DeleteInput(int enum_type){
345
346 vector<Object*>::iterator object;
347 Input* input=NULL;
348
349 for ( object=objects.begin() ; object < objects.end(); object++ ){
350
351 input=(Input*)(*object);
352
353 if (input->InstanceEnum()==enum_type){
354 this->DeleteObject(input);
355 break;
356 }
357 }
358
359 return 1;
360
361}
362/*}}}*/
363/*FUNCTION Inputs::DuplicateInput{{{*/
364void Inputs::DuplicateInput(int original_enum,int new_enum){
365
366 Input* original=NULL;
367 Input* copy=NULL;
368
369 /*Make a copy of the original input: */
370 original=(Input*)this->GetInput(original_enum);
371 if(!original)_error2_("could not find input with enum: " << EnumToStringx(original_enum));
372 copy=(Input*)original->copy();
373
374 /*Change copy enum to reinitialized_enum: */
375 copy->ChangeEnum(new_enum);
376
377 /*Add copy into inputs, it will wipe off the one already there: */
378 this->AddInput((Input*)copy);
379}
380/*}}}*/
381/*FUNCTION Inputs::SpawnTriaInputs{{{*/
382Inputs* Inputs::SpawnTriaInputs(int* indices){
383
384 /*Intermediary*/
385 vector<Object*>::iterator object;
386 Input* inputin=NULL;
387 Input* inputout=NULL;
388
389 /*Output*/
390 Inputs* newinputs=new Inputs();
391
392 /*Go through inputs and call Spawn function*/
393 for ( object=objects.begin() ; object < objects.end(); object++ ){
394
395 /*Create new input*/
396 inputin=(Input*)(*object);
397 inputout=inputin->SpawnTriaInput(indices);
398
399 /*Add input to new inputs*/
400 newinputs->AddObject(inputout);
401 }
402
403 /*Assign output pointer*/
404 return newinputs;
405}
406/*}}}*/
407/*FUNCTION Inputs::AXPY{{{*/
408void Inputs::AXPY(int MeshYEnum, IssmDouble scalar, int MeshXEnum){
409
410 Input* xinput=NULL;
411 Input* yinput=NULL;
412
413 /*Find x and y inputs: */
414 xinput=(Input*)this->GetInput(MeshXEnum);
415 yinput=(Input*)this->GetInput(MeshYEnum);
416
417 /*some checks: */
418 if(!xinput) _error2_(" input " << EnumToStringx(MeshXEnum) << " could not be found!");
419 if(!yinput) _error2_(" input " << EnumToStringx(MeshYEnum) << " could not be found!");
420
421 /*Apply AXPY: */
422 yinput->AXPY(xinput,scalar);
423}
424/*}}}*/
425/*FUNCTION Inputs::Configure{{{*/
426void Inputs::Configure(Parameters* parameters){
427
428 vector<Object*>::iterator object;
429 Input* input=NULL;
430
431 for ( object=objects.begin() ; object < objects.end(); object++ ){
432
433 input=(Input*)(*object);
434 input->Configure(parameters);
435
436 }
437
438}
439/*}}}*/
Note: See TracBrowser for help on using the repository browser.