source: issm/branches/trunk-dlcheng-ASE/src/c/classes/Inputs/Inputs.cpp@ 27955

Last change on this file since 27955 was 27691, checked in by Mathieu Morlighem, 2 years ago

NEW: added averaging method for inputs
File size: 30.2 KB
Line 
1/*\file Inputs.cpp
2 * \brief: Implementation of the Inputs class, derived from DataSet class.
3 */
4
5/*Headers: {{{*/
6#ifdef HAVE_CONFIG_H
7 #include <config.h>
8#else
9#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!"
10#endif
11
12#include "./Input.h"
13#include "./Inputs.h"
14
15#include "./BoolInput.h"
16#include "./IntInput.h"
17#include "./DoubleInput.h"
18#include "./ElementInput.h"
19#include "./SegInput.h"
20#include "./TriaInput.h"
21#include "./PentaInput.h"
22#include "./TransientInput.h"
23#include "./ControlInput.h"
24#include "./DatasetInput.h"
25#include "./ArrayInput.h"
26#include "./IntArrayInput.h"
27using namespace std;
28/*}}}*/
29
30/*Object constructors and destructor*/
31Inputs::Inputs(void){/*{{{*/
32
33 this->numberofelements_local = 0;
34 this->numberofvertices_local = 0;
35
36 /*Initialize pointers*/
37 for(int i=0;i<NUMINPUTS;i++) this->inputs[i] = NULL;
38}
39/*}}}*/
40Inputs::Inputs(int nbe,int nbv){/*{{{*/
41
42 this->numberofelements_local = nbe;
43 this->numberofvertices_local = nbv;
44
45 /*Initialize pointers*/
46 for(int i=0;i<NUMINPUTS;i++) this->inputs[i] = NULL;
47}
48/*}}}*/
49Inputs::~Inputs(){/*{{{*/
50 for(int i=0;i<NUMINPUTS;i++){
51 if(this->inputs[i]) delete this->inputs[i];
52 }
53 return;
54}
55/*}}}*/
56
57Inputs* Inputs::Copy(void){/*{{{*/
58
59 Inputs* output = new Inputs(this->numberofelements_local,this->numberofvertices_local);
60
61 for(int i=0;i<NUMINPUTS;i++){
62 if(this->inputs[i]) output->inputs[i]=this->inputs[i]->copy();
63 }
64
65 return output;
66}/*}}}*/
67void Inputs::DeepEcho(void){/*{{{*/
68 for(int i=0;i<NUMINPUTS;i++) {
69 if(this->inputs[i]) this->inputs[i]->DeepEcho();
70 }
71 return;
72}
73/*}}}*/
74void Inputs::Echo(void){/*{{{*/
75 _printf_("Inputs Echo:\n");
76 for(int i=0;i<NUMINPUTS;i++) {
77 if(this->inputs[i]) _printf_(setw(25)<<EnumToStringx(i+InputsSTARTEnum+1)<<": set as "<<EnumToStringx(this->inputs[i]->ObjectEnum())<<"\n");
78 }
79 return;
80}
81/*}}}*/
82void Inputs::DeepEcho(int enum_in){/*{{{*/
83 int index= EnumToIndex(enum_in);
84 if(this->inputs[index])this->inputs[index]->DeepEcho();
85 return;
86}
87/*}}}*/
88void Inputs::Echo(int enum_in){/*{{{*/
89 _printf_("Inputs Echo:\n");
90 int index= EnumToIndex(enum_in);
91 if(this->inputs[index])this->inputs[index]->Echo();
92 return;
93}
94/*}}}*/
95void Inputs::Marshall(MarshallHandle* marshallhandle){/*{{{*/
96
97 int num_inputs=0;
98 int index;
99
100 int object_enum = InputsEnum;
101 marshallhandle->call(object_enum);
102 marshallhandle->call(this->numberofelements_local);
103 marshallhandle->call(this->numberofvertices_local);
104
105 if(marshallhandle->OperationNumber()!=MARSHALLING_LOAD){
106
107 /*Marshall num_inputs first*/
108 for(int i=0;i<NUMINPUTS;i++){
109 if(this->inputs[i]) num_inputs++;
110 }
111 marshallhandle->call(num_inputs);
112
113 /*Marshall Parameters one by one now*/
114 for(int i=0;i<NUMINPUTS;i++){
115 if(this->inputs[i]){
116 object_enum = this->inputs[i]->ObjectEnum();
117 marshallhandle->call(i);
118 marshallhandle->call(object_enum);
119 this->inputs[i]->Marshall(marshallhandle);
120 }
121 }
122 }
123 else{
124
125 /*Get number of inputs marshalled*/
126 marshallhandle->call(num_inputs);
127
128 /*Recover input2eters one by one*/
129 for(int i=0;i<num_inputs;i++){
130
131 /*Recover enum of object first: */
132 marshallhandle->call(index);
133 marshallhandle->call(object_enum);
134
135 if(object_enum==BoolInputEnum){
136 BoolInput* boolinput2=new BoolInput();
137 boolinput2->Marshall(marshallhandle);
138 this->inputs[index]=boolinput2;
139 }
140 else if(object_enum==IntInputEnum){
141 IntInput* intinput2=new IntInput();
142 intinput2->Marshall(marshallhandle);
143 this->inputs[index]=intinput2;
144 }
145 else if(object_enum==TriaInputEnum){
146 TriaInput* triainput2=new TriaInput();
147 triainput2->Marshall(marshallhandle);
148 this->inputs[index]=triainput2;
149 }
150 else if(object_enum==PentaInputEnum){
151 PentaInput* pentainput2=new PentaInput();
152 pentainput2->Marshall(marshallhandle);
153 this->inputs[index]=pentainput2;
154 }
155 else if(object_enum==ControlInputEnum){
156 ControlInput* input=new ControlInput();
157 input->Marshall(marshallhandle);
158 this->inputs[index]=input;
159 }
160 else if(object_enum==TransientInputEnum){
161 TransientInput* input=new TransientInput();
162 input->Marshall(marshallhandle);
163 this->inputs[index]=input;
164 }
165 else if(object_enum==DatasetInputEnum){
166 DatasetInput* input=new DatasetInput();
167 input->Marshall(marshallhandle);
168 this->inputs[index]=input;
169 }
170 else if(object_enum==ArrayInputEnum){
171 ArrayInput* input=new ArrayInput();
172 input->Marshall(marshallhandle);
173 this->inputs[index]=input;
174 }
175 else{
176 _error_("input "<<EnumToStringx(object_enum)<<" not supported");
177 }
178 }
179 }
180}
181/*}}}*/
182
183void Inputs::AddInput(Input* newinput){/*{{{*/
184
185 /*Get Enum from Param*/
186 _assert_(newinput);
187 int input_enum = newinput->InstanceEnum();
188
189 /*Get index in array*/
190 #ifdef _ISSM_DEBUG_
191 if(input_enum<=InputsSTARTEnum) _error_("Cannot add input: Enum "<<EnumToStringx(input_enum)<<" should appear after InputsSTARTEnum");
192 if(input_enum>=InputsENDEnum) _error_("Cannot add input: Enum "<<EnumToStringx(input_enum)<<" should appear before InputsENDEnum");
193 #endif
194 int index = input_enum - InputsSTARTEnum -1;
195
196 /*Delete input if it already exists*/
197 if(this->inputs[index]){
198 delete this->inputs[index];
199 this->inputs[index] = NULL;
200 }
201
202 /*Add input to array*/
203 this->inputs[index] = newinput;
204}
205/*}}}*/
206void Inputs::ChangeEnum(int oldenumtype,int newenumtype){/*{{{*/
207
208 /*Get indices from enums*/
209 int index_old = EnumToIndex(oldenumtype);
210 int index_new = EnumToIndex(newenumtype);
211
212 /*Delete input if it already exists*/
213 if(this->inputs[index_new]) delete this->inputs[index_new];
214
215 /*Make sure that old one exists*/
216 if(!this->inputs[index_old]){
217 _error_("Input "<<EnumToStringx(oldenumtype)<<" not found");
218 }
219
220 /*Replace Enums*/
221 this->inputs[index_old]->ChangeEnum(newenumtype);
222 this->inputs[index_new] = this->inputs[index_old];
223 this->inputs[index_old] = NULL;
224}/*}}}*/
225void Inputs::Configure(Parameters* parameters){/*{{{*/
226 for(int i=0;i<NUMINPUTS;i++){
227 if(this->inputs[i]) this->inputs[i]->Configure(parameters);
228 }
229}
230/*}}}*/
231int Inputs::DeleteInput(int input_enum){/*{{{*/
232
233 int index = EnumToIndex(input_enum);
234 if(this->inputs[index]){
235 delete this->inputs[index];
236 this->inputs[index] = NULL;
237 }
238
239 return 1;
240}
241/*}}}*/
242void Inputs::DuplicateInput(int original_enum,int new_enum){/*{{{*/
243
244 _assert_(this);
245
246 /*Get indices from enums*/
247 int index_ori = EnumToIndex(original_enum);
248 int index_new = EnumToIndex(new_enum);
249
250 /*Delete input if it already exists*/
251 if(this->inputs[index_new]) delete this->inputs[index_new];
252
253 /*Make sure that old one exists*/
254 if(!this->inputs[index_ori]){
255 _error_("Input "<<EnumToStringx(original_enum)<<" not found");
256 }
257
258 /*Make a copy*/
259 Input* copy=this->inputs[index_ori]->copy();
260
261 /*Add copy*/
262 this->inputs[index_new] = copy;
263}
264/*}}}*/
265void Inputs::ZAXPY(IssmDouble alpha, int xenum, int yenum, int zenum){/*{{{*/
266
267 _assert_(this);
268
269 /*Get indices from enums*/
270 int index_x = EnumToIndex(xenum);
271 int index_y = EnumToIndex(yenum);
272 int index_z = EnumToIndex(zenum);
273
274 /*Delete output if it already exists*/
275 if(this->inputs[index_z]) delete this->inputs[index_z];
276
277 /*Make sure that old one exists*/
278 if(!this->inputs[index_x]) _error_("Input "<<EnumToStringx(xenum)<<" not found");
279 if(!this->inputs[index_y]) _error_("Input "<<EnumToStringx(yenum)<<" not found");
280
281 /*Make a copy*/
282 this->inputs[index_z]=this->inputs[index_y]->copy();
283
284 /*AXPY: */
285 this->inputs[index_z]->AXPY(this->inputs[index_x],alpha);
286}
287/*}}}*/
288void Inputs::AXPY(IssmDouble alpha, int xenum, int yenum ){/*{{{*/
289
290 _assert_(this);
291
292 /*Get indices from enums*/
293 int index_x = EnumToIndex(xenum);
294 int index_y = EnumToIndex(yenum);
295
296 /*Make sure that old one exists*/
297 if(!this->inputs[index_x]) _error_("Input "<<EnumToStringx(xenum)<<" not found");
298 if(!this->inputs[index_y]) _error_("Input "<<EnumToStringx(yenum)<<" not found");
299
300 /*AXPY: */
301 this->inputs[index_y]->AXPY(this->inputs[index_x],alpha);
302}
303/*}}}*/
304void Inputs::Shift(int xenum, IssmDouble alpha){/*{{{*/
305
306 _assert_(this);
307
308 /*Get indices from enums*/
309 int index_x = EnumToIndex(xenum);
310
311 /*Make sure that x exists*/
312 if(!this->inputs[index_x]) _error_("Input "<<EnumToStringx(xenum)<<" not found");
313
314 /*Shift: */
315 this->inputs[index_x]->Shift(alpha);
316}
317/*}}}*/
318void Inputs::AverageAndReplace(int inputenum){/*{{{*/
319
320 _assert_(this);
321
322 /*Get indices from enums*/
323 int index = EnumToIndex(inputenum);
324 if(!this->inputs[index]) _error_("Input "<<EnumToStringx(inputenum)<<" not found");
325
326 this->inputs[index]->AverageAndReplace();
327}
328/*}}}*/
329int Inputs::EnumToIndex(int enum_in){/*{{{*/
330
331 _assert_(this);
332
333 /*Make sure this parameter is at the right place*/
334 #ifdef _ISSM_DEBUG_
335 if(enum_in<=InputsSTARTEnum){
336 //int* temp = xNew<int>(3);
337 _error_("Enum "<<EnumToStringx(enum_in)<<" should appear after InputsSTARTEnum");
338 }
339 if(enum_in>=InputsENDEnum){
340 _error_("Enum "<<EnumToStringx(enum_in)<<" should appear before InputsENDEnum");
341 }
342 #endif
343 return enum_in - InputsSTARTEnum -1;
344}/*}}}*/
345bool Inputs::Exist(int enum_in){/*{{{*/
346
347 _assert_(this);
348
349 int index = EnumToIndex(enum_in);
350 if(this->inputs[index]) return true;
351 return false;
352}
353/*}}}*/
354int Inputs::GetInputObjectEnum(int enum_in){/*{{{*/
355
356 _assert_(this);
357
358 int index = EnumToIndex(enum_in);
359 if(!this->inputs[index]) _error_("Input "<<EnumToStringx(enum_in)<<" not found");
360 return this->inputs[index]->ObjectEnum();
361}
362/*}}}*/
363void Inputs::GetInputsInterpolations(int* pnuminputs,int** pinterpolations,int** pinputenums){/*{{{*/
364
365 /*First count number of inputs*/
366 int count = 0;
367 for(int i=0;i<NUMINPUTS;i++){
368 if(this->inputs[i]) count++;
369 }
370 int numinputs = count;
371
372 /*Allocate output*/
373 int* interpolations = xNew<int>(count);
374 int* enumlist = xNew<int>(count);
375
376 /*Go through all inputs and assign interpolation in vector*/
377 count = 0;
378 for(int i=0;i<NUMINPUTS;i++){
379
380 Input* input=this->inputs[i];
381 if(!input) continue;
382
383 enumlist[count] = i+InputsSTARTEnum+1;
384 switch(input->ObjectEnum()){
385 case BoolInputEnum:
386 case IntInputEnum:
387 interpolations[count] = input->ObjectEnum();
388 break;
389 case TriaInputEnum:
390 interpolations[count] = input->GetResultInterpolation();
391 break;
392 default:
393 _error_("Input "<<EnumToStringx(input->ObjectEnum())<<" not supported yet");
394 }
395 count++;
396 }
397 _assert_(count == numinputs);
398
399 /*Return pointer*/
400 *pnuminputs = numinputs;
401 *pinterpolations = interpolations;
402 *pinputenums = enumlist;
403
404}/*}}}*/
405SegInput* Inputs::GetSegInput(int enum_in){/*{{{*/
406
407 _assert_(this);
408
409 /*Get input id*/
410 int id = EnumToIndex(enum_in);
411
412 /*Check that it has the right format*/
413 Input* input = this->inputs[id];
414 if(!input) return NULL;
415
416 return input->GetSegInput();
417}/*}}}*/
418TriaInput* Inputs::GetTriaInput(int enum_in){/*{{{*/
419
420 _assert_(this);
421
422 /*Get input id*/
423 int id = EnumToIndex(enum_in);
424
425 /*Check that it has the right format*/
426 Input* input = this->inputs[id];
427 if(!input) return NULL;
428
429 return input->GetTriaInput();
430}/*}}}*/
431TriaInput* Inputs::GetTriaInput(int enum_in,IssmDouble time){/*{{{*/
432
433 /*Get input id*/
434 int id = EnumToIndex(enum_in);
435
436 /*Check that it has the right format*/
437 Input* input = this->inputs[id];
438 if(!input) return NULL;
439
440 if(input->ObjectEnum()==TransientInputEnum){
441 return xDynamicCast<TransientInput*>(input)->GetTriaInput(time);
442 }
443 else{
444 return input->GetTriaInput();
445 }
446}/*}}}*/
447TriaInput* Inputs::GetTriaInput(int enum_in,IssmDouble start_time,IssmDouble end_time,int averaging_method){/*{{{*/
448
449 /*Get input id*/
450 int id = EnumToIndex(enum_in);
451
452 /*Check that it has the right format*/
453 Input* input = this->inputs[id];
454 if(!input) return NULL;
455
456 if(input->ObjectEnum()==TransientInputEnum){
457 return xDynamicCast<TransientInput*>(input)->GetTriaInput(start_time,end_time,averaging_method);
458 }
459 else{
460 _error_("Input "<<EnumToStringx(enum_in)<<" is not an TransientInput");
461 }
462}/*}}}*/
463PentaInput* Inputs::GetPentaInput(int enum_in){/*{{{*/
464
465 /*Get input id*/
466 int id = EnumToIndex(enum_in);
467
468 /*Check that it has the right format*/
469 Input* input = this->inputs[id];
470 if(!input) return NULL;
471
472 return input->GetPentaInput();
473}/*}}}*/
474PentaInput* Inputs::GetPentaInput(int enum_in,IssmDouble time){/*{{{*/
475
476 /*Get input id*/
477 int id = EnumToIndex(enum_in);
478
479 /*Check that it has the right format*/
480 Input* input = this->inputs[id];
481 if(!input) return NULL;
482
483 if(input->ObjectEnum()==TransientInputEnum){
484 return xDynamicCast<TransientInput*>(input)->GetPentaInput(time);
485 }
486 else{
487 return input->GetPentaInput();
488 }
489}/*}}}*/
490PentaInput* Inputs::GetPentaInput(int enum_in,IssmDouble start_time,IssmDouble end_time,int averaging_method){/*{{{*/
491
492 /*Get input id*/
493 int id = EnumToIndex(enum_in);
494
495 /*Check that it has the right format*/
496 Input* input = this->inputs[id];
497 if(!input) return NULL;
498
499 if(input->ObjectEnum()==TransientInputEnum){
500 return xDynamicCast<TransientInput*>(input)->GetPentaInput(start_time,end_time,averaging_method);
501 }
502 else{
503 _error_("Input "<<EnumToStringx(enum_in)<<" is not an TransientInput");
504 }
505}/*}}}*/
506TransientInput* Inputs::GetTransientInput(int enum_in){/*{{{*/
507
508 /*Get input id*/
509 int id = EnumToIndex(enum_in);
510
511 /*Check that it has the right format*/
512 Input* input = this->inputs[id];
513 if(!input) return NULL;
514
515 if(input->ObjectEnum() != TransientInputEnum){
516 _error_("Input "<<EnumToStringx(enum_in)<<" is not an TransientInput");
517 }
518
519 /*Cast and return*/
520 TransientInput* output = xDynamicCast<TransientInput*>(input);
521 return output;
522}/*}}}*/
523ElementInput* Inputs::GetControlInputData(int enum_in,const char* data){/*{{{*/
524
525 /*Get input id*/
526 int id = EnumToIndex(enum_in);
527
528 /*Check that it has the right format*/
529 Input* input = this->inputs[id];
530 if(!input) return NULL;
531 if(input->ObjectEnum() != ControlInputEnum){
532 _error_("Input "<<EnumToStringx(enum_in)<<" is not an ControlInput");
533 }
534
535 /*Cast and return*/
536 return xDynamicCast<ControlInput*>(input)->GetInput(data);
537}/*}}}*/
538DatasetInput* Inputs::GetDatasetInput(int enum_in){/*{{{*/
539
540 /*Get input id*/
541 int id = EnumToIndex(enum_in);
542
543 /*Check that it has the right format*/
544 Input* input = this->inputs[id];
545 if(!input) return NULL;
546 if(input->ObjectEnum() != DatasetInputEnum){
547 _error_("Input "<<EnumToStringx(enum_in)<<" is not an DatasetInput");
548 }
549
550 /*Cast and return*/
551 return xDynamicCast<DatasetInput*>(input);
552}/*}}}*/
553ControlInput* Inputs::GetControlInput(int enum_in){/*{{{*/
554
555 /*Get input id*/
556 int id = EnumToIndex(enum_in);
557
558 /*Check that it has the right format*/
559 Input* input = this->inputs[id];
560 if(!input) return NULL;
561 if(input->ObjectEnum() != ControlInputEnum){
562 _error_("Input "<<EnumToStringx(enum_in)<<" is not an ControlInput");
563 }
564
565 /*Cast and return*/
566 return xDynamicCast<ControlInput*>(input);
567}/*}}}*/
568void Inputs::GetArrayPtr(int enum_in,int row,IssmDouble** pvalues,int* pN){/*{{{*/
569
570 /*Get input id*/
571 int id = EnumToIndex(enum_in);
572
573 /*Create it if necessary*/
574 if(this->inputs[id]){
575 if(this->inputs[id]->ObjectEnum()!=ArrayInputEnum) _error_(EnumToStringx(this->inputs[id]->ObjectEnum())<<" cannot return an array");
576 }
577 else{
578 _error_("Input "<<EnumToStringx(enum_in)<<" not found");
579 }
580
581 /*Set input*/
582 ArrayInput* input = xDynamicCast<ArrayInput*>(this->inputs[id]);
583 input->GetArrayPtr(row,pvalues,pN);
584}/*}}}*/
585void Inputs::GetIntArrayPtr(int enum_in,int row,int** pvalues,int* pN){/*{{{*/
586
587 /*Get input id*/
588 int id = EnumToIndex(enum_in);
589
590 /*Create it if necessary*/
591 if(this->inputs[id]){
592 if(this->inputs[id]->ObjectEnum()!=IntArrayInputEnum) _error_(EnumToStringx(this->inputs[id]->ObjectEnum())<<" cannot return an int array");
593 }
594 else{
595 _error_("Input "<<EnumToStringx(enum_in)<<" not found");
596 }
597
598 /*Set input*/
599 IntArrayInput* input = xDynamicCast<IntArrayInput*>(this->inputs[id]);
600 input->GetArrayPtr(row,pvalues,pN);
601}/*}}}*/
602void Inputs::GetArray(int enum_in,int row,IssmDouble** pvalues,int* pN){/*{{{*/
603
604 /*Get input id*/
605 int id = EnumToIndex(enum_in);
606
607 /*Create it if necessary*/
608 if(this->inputs[id]){
609 if(this->inputs[id]->ObjectEnum()!=ArrayInputEnum) _error_(EnumToStringx(this->inputs[id]->ObjectEnum())<<" cannot return an array");
610 }
611 else{
612 _error_("Input "<<EnumToStringx(enum_in)<<" not found");
613 }
614
615 /*Set input*/
616 ArrayInput* input = xDynamicCast<ArrayInput*>(this->inputs[id]);
617 input->GetArray(row,pvalues,pN);
618}/*}}}*/
619void Inputs::GetIntArray(int enum_in,int row,int** pvalues,int* pN){/*{{{*/
620
621 /*Get input id*/
622 int id = EnumToIndex(enum_in);
623
624 /*Create it if necessary*/
625 if(this->inputs[id]){
626 if(this->inputs[id]->ObjectEnum()!=IntArrayInputEnum) _error_(EnumToStringx(this->inputs[id]->ObjectEnum())<<" cannot return an int array");
627 }
628 else{
629 _error_("Input "<<EnumToStringx(enum_in)<<" not found");
630 }
631
632 /*Set input*/
633 IntArrayInput* input = xDynamicCast<IntArrayInput*>(this->inputs[id]);
634 input->GetArray(row,pvalues,pN);
635}/*}}}*/
636void Inputs::GetInputValue(bool* pvalue,int enum_in,int index){/*{{{*/
637
638 /*Get input id*/
639 int id = EnumToIndex(enum_in);
640
641 /*Create it if necessary*/
642 if(this->inputs[id]){
643 if(this->inputs[id]->ObjectEnum()!=BoolInputEnum) _error_(EnumToStringx(this->inputs[id]->ObjectEnum())<<" cannot return a bool");
644 }
645 else{
646 _error_("Input "<<EnumToStringx(enum_in)<<" not found");
647 }
648
649 /*Set input*/
650 BoolInput* input = xDynamicCast<BoolInput*>(this->inputs[id]);
651 input->GetInput(pvalue,index);
652}/*}}}*/
653void Inputs::GetInputValue(int* pvalue,int enum_in,int index){/*{{{*/
654
655 /*Get input id*/
656 int id = EnumToIndex(enum_in);
657
658 /*Create it if necessary*/
659 if(this->inputs[id]){
660 if(this->inputs[id]->ObjectEnum()!=IntInputEnum) _error_(EnumToStringx(this->inputs[id]->ObjectEnum())<<" cannot return a int");
661 }
662 else{
663 int* temp = xNew<int>(3);
664 _error_("Input "<<EnumToStringx(enum_in)<<" not found");
665 }
666
667 /*Set input*/
668 IntInput* input = xDynamicCast<IntInput*>(this->inputs[id]);
669 input->GetInput(pvalue,index);
670}/*}}}*/
671void Inputs::GetInputValue(IssmDouble* pvalue,int enum_in,int index){/*{{{*/
672
673 /*Get input id*/
674 int id = EnumToIndex(enum_in);
675
676 /*Create it if necessary*/
677 if(this->inputs[id]){
678 if(this->inputs[id]->ObjectEnum()!=DoubleInputEnum) _error_(EnumToStringx(this->inputs[id]->ObjectEnum())<<" cannot return a double!");
679 }
680 else{
681 int* temp = xNew<int>(3);
682 _error_("Input "<<EnumToStringx(enum_in)<<" not found");
683 }
684
685 /*Set input*/
686 DoubleInput* input = xDynamicCast<DoubleInput*>(this->inputs[id]);
687 input->GetInput(pvalue,index);
688
689}/*}}}*/
690void Inputs::ResultInterpolation(int* pinterpolation,int* pnodesperelement,int* parray_size, int output_enum){/*{{{*/
691
692 /*Get input */
693 int index = EnumToIndex(output_enum);
694 Input* input = this->inputs[index];
695
696 /*Check that it is found*/
697 if(!input){
698 _error_("Input "<<EnumToStringx(output_enum)<<" not found and cannot be added to model results");
699 }
700
701 /*Assign output pointer*/
702 *pinterpolation = input->GetResultInterpolation();
703 *pnodesperelement = input->GetResultNumberOfNodes();
704 *parray_size = input->GetResultArraySize();
705}/*}}}*/
706void Inputs::SetInput(int enum_in,int index,bool value){/*{{{*/
707
708 /*Get input id*/
709 int id = EnumToIndex(enum_in);
710
711 /*Create it if necessary*/
712 if(this->inputs[id]){
713 if(this->inputs[id]->ObjectEnum()!=BoolInputEnum) _error_("cannot add a bool to a "<<EnumToStringx(this->inputs[id]->ObjectEnum()));
714 }
715 else{
716 this->inputs[id] = new BoolInput(this->numberofelements_local);
717 }
718
719 /*Set input*/
720 BoolInput* input = xDynamicCast<BoolInput*>(this->inputs[id]);
721 input->SetInput(index,value);
722}/*}}}*/
723void Inputs::SetInput(int enum_in,int index,int value){/*{{{*/
724
725 /*Get input id*/
726 int id = EnumToIndex(enum_in);
727
728 /*Create it if necessary*/
729 if(this->inputs[id]){
730 if(this->inputs[id]->ObjectEnum()!=IntInputEnum) _error_("cannot add an int to a "<<EnumToStringx(this->inputs[id]->ObjectEnum()));
731 }
732 else{
733 this->inputs[id] = new IntInput(this->numberofelements_local);
734 }
735
736 /*Set input*/
737 IntInput* input = xDynamicCast<IntInput*>(this->inputs[id]);
738 input->SetInput(index,value);
739}/*}}}*/
740void Inputs::SetDoubleInput(int enum_in,int index,IssmDouble value){/*{{{*/
741
742 /*Get input id*/
743 int id = EnumToIndex(enum_in);
744
745 /*Create it if necessary*/
746 if(this->inputs[id]){
747 if(this->inputs[id]->ObjectEnum()!=DoubleInputEnum) _error_("cannot add a double to a "<<EnumToStringx(this->inputs[id]->ObjectEnum()));
748 }
749 else{
750 this->inputs[id] = new DoubleInput(this->numberofelements_local);
751 }
752
753 /*Set input*/
754 DoubleInput* input = xDynamicCast<DoubleInput*>(this->inputs[id]);
755 input->SetInput(index,value);
756}/*}}}*/
757void Inputs::SetArrayInput(int enum_in,int row,IssmDouble* values,int numlayers){/*{{{*/
758
759 bool recreate = false;
760
761 /*Get input id*/
762 int id = EnumToIndex(enum_in);
763
764 /*Create it if necessary*/
765 if(this->inputs[id]){
766 if(this->inputs[id]->ObjectEnum()!=ArrayInputEnum){
767 delete this->inputs[id];
768 recreate = true;
769 }
770 }
771 else{
772 recreate = true;
773 }
774
775 if(recreate){
776 this->inputs[id] = new ArrayInput(this->numberofelements_local);
777 }
778
779 /*Set input*/
780 ArrayInput* input = xDynamicCast<ArrayInput*>(this->inputs[id]);
781 input->SetInput(row,numlayers,values);
782}/*}}}*/
783void Inputs::SetIntArrayInput(int enum_in,int row,int* values,int numlayers){/*{{{*/
784
785 bool recreate = false;
786
787 /*Get input id*/
788 int id = EnumToIndex(enum_in);
789
790 /*Create it if necessary*/
791 if(this->inputs[id]){
792 if(this->inputs[id]->ObjectEnum()!=IntArrayInputEnum){
793 delete this->inputs[id];
794 recreate = true;
795 }
796 }
797 else{
798 recreate = true;
799 }
800
801 if(recreate){
802 this->inputs[id] = new IntArrayInput(this->numberofelements_local);
803 }
804
805 /*Set input*/
806 IntArrayInput* input = xDynamicCast<IntArrayInput*>(this->inputs[id]);
807 input->SetInput(row,numlayers,values);
808}/*}}}*/
809TransientInput* Inputs::SetDatasetTransientInput(int enum_in,int dataset_id,IssmDouble* times,int numtimes){/*{{{*/
810
811 bool recreate = false;
812 /*Get input id*/
813 int id = EnumToIndex(enum_in);
814
815 /*Create it if necessary*/
816 if(this->inputs[id]){
817 if(this->inputs[id]->ObjectEnum()!=DatasetInputEnum){
818 delete this->inputs[id];
819 recreate = true;
820 }
821 }
822 else{
823 recreate = true;
824 }
825
826 if(recreate){
827 this->inputs[id] = new DatasetInput(this->numberofelements_local,this->numberofvertices_local);
828 }
829
830 /*Get Dataset Input now*/
831 DatasetInput* input = xDynamicCast<DatasetInput*>(this->inputs[id]);
832
833 /*Create and return transient input*/
834 return input->SetTransientInput(dataset_id,times,numtimes);
835}/*}}}*/
836void Inputs::SetTransientInput(int enum_in,IssmDouble* times,int numtimes){/*{{{*/
837
838 /*Get input id*/
839 int id = EnumToIndex(enum_in);
840
841 /*Create it if necessary*/
842 if(this->inputs[id]){
843 /*Input already there, make sure it is the right type*/
844 if(this->inputs[id]->ObjectEnum()!=TransientInputEnum){
845 _error_("cannot add a TransientInput to a "<<EnumToStringx(this->inputs[id]->ObjectEnum()));
846 }
847 }
848 else{
849 this->inputs[id] = new TransientInput(enum_in,this->numberofelements_local,this->numberofvertices_local,times,numtimes);
850 }
851}/*}}}*/
852void Inputs::SetControlInput(int enum_in,int layout,int interpolation,int control_id){/*{{{*/
853
854 bool recreate = false;
855
856 /*Get input id*/
857 int id = EnumToIndex(enum_in);
858
859 /*Create it if necessary*/
860 if(this->inputs[id]){
861 if(this->inputs[id]->ObjectEnum()!=ControlInputEnum){
862 delete this->inputs[id];
863 recreate = true;
864 }
865 }
866 else{
867 recreate = true;
868 }
869
870 if(recreate){
871 this->inputs[id] = new ControlInput(this->numberofelements_local,this->numberofvertices_local,layout,interpolation,control_id);
872 }
873
874}/*}}}*/
875void Inputs::SetTransientControlInput(int enum_in,int control_id,IssmDouble* times,int numtimes){/*{{{*/
876
877 bool recreate = false;
878
879 /*Get input id*/
880 int id = EnumToIndex(enum_in);
881
882 /*Create it if necessary*/
883 if(this->inputs[id]){
884 if(this->inputs[id]->ObjectEnum()!=ControlInputEnum){
885 delete this->inputs[id];
886 recreate = true;
887 }
888 }
889 else{
890 recreate = true;
891 }
892
893 if(recreate){
894 this->inputs[id] = new ControlInput(enum_in,this->numberofelements_local,this->numberofvertices_local,control_id,times,numtimes);
895 }
896
897}/*}}}*/
898void Inputs::SetTriaControlInputGradient(int enum_in,int interpolation,int numindices,int* indices,IssmDouble* values){/*{{{*/
899
900 /*Get input id*/
901 int id = EnumToIndex(enum_in);
902
903 /*Create it if necessary*/
904 if(!this->inputs[id]) _error_("could not find Input "<<EnumToStringx(enum_in));
905 if( this->inputs[id]->ObjectEnum()!=ControlInputEnum) _error_("Input "<<EnumToStringx(enum_in)<<" is not a ControlInput");
906
907 /*Set input*/
908 ControlInput* input = xDynamicCast<ControlInput*>(this->inputs[id]);
909 input->SetGradient(interpolation,numindices,indices,values);
910}/*}}}*/
911void Inputs::SetTriaControlInputGradient(int enum_in,int interpolation,int numindices,int* indices,IssmDouble* values,int n){/*{{{*/
912
913 /*Get input id*/
914 int id = EnumToIndex(enum_in);
915
916 /*Create it if necessary*/
917 if(!this->inputs[id]) _error_("could not find Input "<<EnumToStringx(enum_in));
918 if( this->inputs[id]->ObjectEnum()!=ControlInputEnum) _error_("Input "<<EnumToStringx(enum_in)<<" is not a ControlInput");
919
920 /*Set input*/
921 ControlInput* input = xDynamicCast<ControlInput*>(this->inputs[id]);
922 input->SetGradient(interpolation,numindices,indices,values,n);
923}/*}}}*/
924void Inputs::SetTriaDatasetInput(int enum_in,int id_in,int interpolation,int numindices,int* indices,IssmDouble* values){/*{{{*/
925
926 bool recreate = false;
927 /*Get input id*/
928 int id = EnumToIndex(enum_in);
929
930 /*Create it if necessary*/
931 if(this->inputs[id]){
932 if(this->inputs[id]->ObjectEnum()!=DatasetInputEnum){
933 delete this->inputs[id];
934 recreate = true;
935 }
936 }
937 else{
938 recreate = true;
939 }
940
941 if(recreate){
942 this->inputs[id] = new DatasetInput(this->numberofelements_local,this->numberofvertices_local);
943 }
944
945 /*Set input*/
946 DatasetInput* input = xDynamicCast<DatasetInput*>(this->inputs[id]);
947 input->SetTriaInput(id_in,P1Enum,numindices,indices,values);
948}/*}}}*/
949void Inputs::SetTriaInput(int enum_in,int interpolation,int row,IssmDouble value){/*{{{*/
950
951 /*This one only supports P0 and P1 because it assumes col=0*/
952 _assert_(interpolation==P0Enum || interpolation==P1Enum);
953
954 /*Get input id*/
955 int id = EnumToIndex(enum_in);
956
957 /*Create it if necessary*/
958 if(this->inputs[id]){
959 if(this->inputs[id]->ObjectEnum()!=TriaInputEnum) _error_("cannot add a bool to a "<<EnumToStringx(this->inputs[id]->ObjectEnum()));
960 }
961 else{
962 this->inputs[id] = new TriaInput(this->numberofelements_local,this->numberofvertices_local,interpolation);
963 }
964
965 /*Set input*/
966 TriaInput* input = xDynamicCast<TriaInput*>(this->inputs[id]);
967 input->SetInput(interpolation,row,value);
968}/*}}}*/
969void Inputs::SetTriaInput(int enum_in,int interpolation,int numindices,int* indices,IssmDouble* values){/*{{{*/
970
971 /*Get input id*/
972 int id = EnumToIndex(enum_in);
973
974 /*Create it if necessary*/
975 if(this->inputs[id]){
976 if(this->inputs[id]->ObjectEnum()!=TriaInputEnum){
977 _error_("cannot add Element values to a "<<EnumToStringx(this->inputs[id]->ObjectEnum())<<" while trying to set "<<EnumToStringx(enum_in));
978 }
979 }
980 else{
981 this->inputs[id] = new TriaInput(this->numberofelements_local,this->numberofvertices_local,interpolation);
982 }
983
984 /*Set input*/
985 TriaInput* input = xDynamicCast<TriaInput*>(this->inputs[id]);
986 input->SetInput(interpolation,numindices,indices,values);
987}/*}}}*/
988void Inputs::SetTriaInput(int enum_in,int interpolation,int row,int numindices,IssmDouble* values){/*{{{*/
989
990 /*Get input id*/
991 int id = EnumToIndex(enum_in);
992
993 /*Create it if necessary*/
994 if(this->inputs[id]){
995 if(this->inputs[id]->ObjectEnum()!=TriaInputEnum) _error_("cannot add Element values to a "<<EnumToStringx(this->inputs[id]->ObjectEnum()));
996 }
997 else{
998 this->inputs[id] = new TriaInput(this->numberofelements_local,this->numberofvertices_local,interpolation);
999 }
1000
1001 /*Set input*/
1002 TriaInput* input = xDynamicCast<TriaInput*>(this->inputs[id]);
1003 input->SetInput(interpolation,row,numindices,values);
1004}/*}}}*/
1005void Inputs::SetPentaControlInputGradient(int enum_in,int interpolation,int numindices,int* indices,IssmDouble* values){/*{{{*/
1006
1007 /*Get input id*/
1008 int id = EnumToIndex(enum_in);
1009
1010 /*Create it if necessary*/
1011 if(!this->inputs[id]) _error_("could not find Input "<<EnumToStringx(enum_in));
1012 if( this->inputs[id]->ObjectEnum()!=ControlInputEnum) _error_("Input "<<EnumToStringx(enum_in)<<" is not a ControlInput");
1013
1014 /*Set input*/
1015 ControlInput* input = xDynamicCast<ControlInput*>(this->inputs[id]);
1016 input->SetGradient(interpolation,numindices,indices,values);
1017}/*}}}*/
1018void Inputs::SetPentaDatasetInput(int enum_in,int id_in,int interpolation,int numindices,int* indices,IssmDouble* values){/*{{{*/
1019
1020 bool recreate = false;
1021 /*Get input id*/
1022 int id = EnumToIndex(enum_in);
1023
1024 /*Create it if necessary*/
1025 if(this->inputs[id]){
1026 if(this->inputs[id]->ObjectEnum()!=DatasetInputEnum){
1027 delete this->inputs[id];
1028 recreate = true;
1029 }
1030 }
1031 else{
1032 recreate = true;
1033 }
1034
1035 if(recreate){
1036 this->inputs[id] = new DatasetInput(this->numberofelements_local,this->numberofvertices_local);
1037 }
1038
1039 /*Set input*/
1040 DatasetInput* input = xDynamicCast<DatasetInput*>(this->inputs[id]);
1041 input->SetPentaInput(id_in,P1Enum,numindices,indices,values);
1042}/*}}}*/
1043void Inputs::SetPentaInput(int enum_in,int interpolation,int row,IssmDouble value){/*{{{*/
1044
1045 /*This one only supports P0 and P1 because it assumes col=0*/
1046 _assert_(interpolation==P0Enum || interpolation==P1Enum);
1047
1048 /*Get input id*/
1049 int id = EnumToIndex(enum_in);
1050
1051 /*Create it if necessary*/
1052 if(this->inputs[id]){
1053 if(this->inputs[id]->ObjectEnum()!=PentaInputEnum) _error_("cannot add a bool to a "<<EnumToStringx(this->inputs[id]->ObjectEnum()));
1054 }
1055 else{
1056 this->inputs[id] = new PentaInput(this->numberofelements_local,this->numberofvertices_local,interpolation);
1057 }
1058
1059 /*Set input*/
1060 PentaInput* input = xDynamicCast<PentaInput*>(this->inputs[id]);
1061 input->SetInput(interpolation,row,value);
1062}/*}}}*/
1063void Inputs::SetPentaInput(int enum_in,int interpolation,int numindices,int* indices,IssmDouble* values){/*{{{*/
1064
1065 /*Get input id*/
1066 int id = EnumToIndex(enum_in);
1067
1068 /*Create it if necessary*/
1069 if(this->inputs[id]){
1070 if(this->inputs[id]->ObjectEnum()!=PentaInputEnum) _error_("cannot add Element values to a "<<EnumToStringx(this->inputs[id]->ObjectEnum()));
1071 }
1072 else{
1073 this->inputs[id] = new PentaInput(this->numberofelements_local,this->numberofvertices_local,interpolation);
1074 }
1075
1076 /*Set input*/
1077 PentaInput* input = xDynamicCast<PentaInput*>(this->inputs[id]);
1078 input->SetInput(interpolation,numindices,indices,values);
1079}/*}}}*/
1080void Inputs::SetPentaInput(int enum_in,int interpolation,int row,int numindices,IssmDouble* values){/*{{{*/
1081
1082 /*Get input id*/
1083 int id = EnumToIndex(enum_in);
1084
1085 /*Create it if necessary*/
1086 if(this->inputs[id]){
1087 if(this->inputs[id]->ObjectEnum()!=PentaInputEnum) _error_("cannot add Element values to a "<<EnumToStringx(this->inputs[id]->ObjectEnum()));
1088 }
1089 else{
1090 this->inputs[id] = new PentaInput(this->numberofelements_local,this->numberofvertices_local,interpolation);
1091 }
1092
1093 /*Set input*/
1094 PentaInput* input = xDynamicCast<PentaInput*>(this->inputs[id]);
1095 input->SetInput(interpolation,row,numindices,values);
1096}/*}}}*/
Note: See TracBrowser for help on using the repository browser.