source: issm/trunk/src/c/objects/Inputs/ControlInput.cpp@ 10135

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

Changed GetParameterValue to GetInputValue because it is actually a method of inputs not parameters which is confusing
File size: 14.0 KB
Line 
1/*!\file ControlInput.c
2 * \brief: implementation of the ControlInput object
3 */
4
5#ifdef HAVE_CONFIG_H
6 #include <config.h>
7#else
8#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!"
9#endif
10
11#include <stdio.h>
12#include <string.h>
13#include "../objects.h"
14#include "../../EnumDefinitions/EnumDefinitions.h"
15#include "../../shared/shared.h"
16#include "../../Container/Container.h"
17#include "../../include/include.h"
18
19/*ControlInput constructors and destructor*/
20/*FUNCTION ControlInput::ControlInput(){{{1*/
21ControlInput::ControlInput(){
22 control_id = 0;
23 values = NULL;
24 savedvalues = NULL;
25 minvalues = NULL;
26 maxvalues = NULL;
27 gradient = NULL;
28}
29/*}}}*/
30/*FUNCTION ControlInput::ControlInput(int enum_type,int enum_input,double* pvalues,double* pmin,double* pmax,int id){{{1*/
31ControlInput::ControlInput(int in_enum_type,int enum_input,double* pvalues,double* pmin,double* pmax,int id){
32
33 control_id=id;
34 enum_type=in_enum_type;
35
36 switch(enum_input){
37 case TriaVertexInputEnum:
38 values =new TriaVertexInput(enum_type,pvalues);
39 savedvalues=new TriaVertexInput(enum_type,pvalues);
40 minvalues =new TriaVertexInput(enum_type,pmin);
41 maxvalues =new TriaVertexInput(enum_type,pmax);
42 break;
43 case PentaVertexInputEnum:
44 values =new PentaVertexInput(enum_type,pvalues);
45 savedvalues=new PentaVertexInput(enum_type,pvalues);
46 minvalues =new PentaVertexInput(enum_type,pmin);
47 maxvalues =new PentaVertexInput(enum_type,pmax);
48 break;
49 default:
50 _error_("Input of Enum %s not supported yet by ControlInput",EnumToStringx(enum_input));
51 }
52 gradient =NULL;
53}
54/*}}}*/
55/*FUNCTION ControlInput::~ControlInput(){{{1*/
56ControlInput::~ControlInput(){
57 delete values;
58 delete savedvalues;
59 delete minvalues;
60 delete maxvalues;
61 delete gradient;
62}
63/*}}}*/
64
65/*Object virtual functions definitions:*/
66 /*FUNCTION ControlInput::Echo {{{1*/
67void ControlInput::Echo(void){
68 this->DeepEcho();
69}
70/*}}}*/
71/*FUNCTION ControlInput::DeepEcho{{{1*/
72void ControlInput::DeepEcho(void){
73
74 printf("ControlInput:\n");
75 printf(" enum: %i (%s)\n",this->enum_type,EnumToStringx(this->enum_type));
76 printf("---values: \n"); if (values) values->Echo();
77 printf("---savedvalues: \n");if (savedvalues) savedvalues->Echo();
78 printf("---minvalues: \n"); if (minvalues) minvalues->Echo();
79 printf("---maxvalues: \n"); if (maxvalues) maxvalues->Echo();
80 printf("---gradient: \n"); if (gradient) gradient->Echo();
81}
82/*}}}*/
83/*FUNCTION ControlInput::Id{{{1*/
84int ControlInput::Id(void){ return -1; }
85/*}}}*/
86/*FUNCTION ControlInput::MyRank{{{1*/
87int ControlInput::MyRank(void){
88 extern int my_rank;
89 return my_rank;
90}
91/*}}}*/
92#ifdef _SERIAL_
93/*FUNCTION ControlInput::Marshall{{{1*/
94void ControlInput::Marshall(char** pmarshalled_dataset){
95
96 char* marshalled_dataset=NULL;
97 int enum_value=0;
98 int flag;
99
100 /*recover marshalled_dataset: */
101 marshalled_dataset=*pmarshalled_dataset;
102
103 /*get enum value of ControlInput: */
104 enum_value=ControlInputEnum;
105
106 /*marshall enum: */
107 memcpy(marshalled_dataset,&enum_value,sizeof(enum_value));marshalled_dataset+=sizeof(enum_value);
108
109 /*marshall enum_type: */
110 memcpy(marshalled_dataset,&enum_type,sizeof(enum_type));marshalled_dataset+=sizeof(enum_type);
111 memcpy(marshalled_dataset,&control_id,sizeof(control_id));marshalled_dataset+=sizeof(control_id);
112
113 /*marshal values*/
114 if(!values){
115 flag=0;
116 memcpy(marshalled_dataset,&flag,sizeof(flag));marshalled_dataset+=sizeof(flag);
117 }
118 else{
119 flag=1;
120 memcpy(marshalled_dataset,&flag,sizeof(flag));marshalled_dataset+=sizeof(flag);
121 this->values->Marshall(&marshalled_dataset);
122 }
123
124 /*marshal savedvalues*/
125 if(!savedvalues){
126 flag=0;
127 memcpy(marshalled_dataset,&flag,sizeof(flag));marshalled_dataset+=sizeof(flag);
128 }
129 else{
130 flag=1;
131 memcpy(marshalled_dataset,&flag,sizeof(flag));marshalled_dataset+=sizeof(flag);
132 this->savedvalues->Marshall(&marshalled_dataset);
133 }
134
135 /*marshal minvalues*/
136 if(!minvalues){
137 flag=0;
138 memcpy(marshalled_dataset,&flag,sizeof(flag));marshalled_dataset+=sizeof(flag);
139 }
140 else{
141 flag=1;
142 memcpy(marshalled_dataset,&flag,sizeof(flag));marshalled_dataset+=sizeof(flag);
143 this->minvalues->Marshall(&marshalled_dataset);
144 }
145
146 /*marshal maxvalues*/
147 if(!maxvalues){
148 flag=0;
149 memcpy(marshalled_dataset,&flag,sizeof(flag));marshalled_dataset+=sizeof(flag);
150 }
151 else{
152 flag=1;
153 memcpy(marshalled_dataset,&flag,sizeof(flag));marshalled_dataset+=sizeof(flag);
154 this->maxvalues->Marshall(&marshalled_dataset);
155 }
156
157 /*marshal gradient*/
158 if(!gradient){
159 flag=0;
160 memcpy(marshalled_dataset,&flag,sizeof(flag));marshalled_dataset+=sizeof(flag);
161 }
162 else{
163 flag=1;
164 memcpy(marshalled_dataset,&flag,sizeof(flag));marshalled_dataset+=sizeof(flag);
165 this->gradient->Marshall(&marshalled_dataset);
166 }
167
168 /*clean up and assign output pointer*/
169 *pmarshalled_dataset=marshalled_dataset;
170}
171/*}}}*/
172/*FUNCTION ControlInput::MarshallSize{{{1*/
173int ControlInput::MarshallSize(){
174
175 int size=0;
176
177 size=sizeof(enum_type)+
178 +sizeof(control_id)
179 +5*sizeof(int) //5 flags
180 +sizeof(int); //sizeof(int) for enum value
181
182 if(values) size+=values->MarshallSize();
183 if(savedvalues)size+=savedvalues->MarshallSize();
184 if(minvalues)size+=minvalues->MarshallSize();
185 if(maxvalues)size+=maxvalues->MarshallSize();
186 if(gradient) size+=gradient->MarshallSize();
187 return size;
188}
189/*}}}*/
190/*FUNCTION ControlInput::Demarshall{{{1*/
191void ControlInput::Demarshall(char** pmarshalled_dataset){
192
193 char* marshalled_dataset=NULL;
194 int flag,input_enum_type;
195
196 /*recover marshalled_dataset: */
197 marshalled_dataset=*pmarshalled_dataset;
198
199 /*this time, no need to get enum type, the pointer directly points to the beginning of the
200 *object data (thanks to DataSet::Demarshall):*/
201 memcpy(&enum_type,marshalled_dataset,sizeof(enum_type));marshalled_dataset+=sizeof(enum_type);
202 memcpy(&control_id,marshalled_dataset,sizeof(control_id));marshalled_dataset+=sizeof(control_id);
203
204 /*Demarshal values*/
205 memcpy(&flag,marshalled_dataset,sizeof(int));marshalled_dataset+=sizeof(int);
206 if(flag){
207 memcpy(&input_enum_type,marshalled_dataset,sizeof(int)); marshalled_dataset+=sizeof(int);
208 if(input_enum_type==PentaVertexInputEnum){
209 values=new PentaVertexInput();
210 values->Demarshall(&marshalled_dataset);
211 }
212 else if(input_enum_type==TriaVertexInputEnum){
213 values=new TriaVertexInput();
214 values->Demarshall(&marshalled_dataset);
215 }
216 else _error_("Not supported yet");
217 }
218 else{
219 values=NULL;
220 }
221
222 /*Demarshal savedvalues*/
223 memcpy(&flag,marshalled_dataset,sizeof(int));marshalled_dataset+=sizeof(int);
224 if(flag){
225 memcpy(&input_enum_type,marshalled_dataset,sizeof(int)); marshalled_dataset+=sizeof(int);
226 if(input_enum_type==PentaVertexInputEnum){
227 savedvalues=new PentaVertexInput();
228 savedvalues->Demarshall(&marshalled_dataset);
229 }
230 else if(input_enum_type==TriaVertexInputEnum){
231 savedvalues=new TriaVertexInput();
232 savedvalues->Demarshall(&marshalled_dataset);
233 }
234 else _error_("Not supported yet");
235 }
236 else{
237 savedvalues=NULL;
238 }
239
240 /*Demarshal minvalues*/
241 memcpy(&flag,marshalled_dataset,sizeof(int));marshalled_dataset+=sizeof(int);
242 if(flag){
243 memcpy(&input_enum_type,marshalled_dataset,sizeof(int)); marshalled_dataset+=sizeof(int);
244 if(input_enum_type==PentaVertexInputEnum){
245 minvalues=new PentaVertexInput();
246 minvalues->Demarshall(&marshalled_dataset);
247 }
248 else if(input_enum_type==TriaVertexInputEnum){
249 minvalues=new TriaVertexInput();
250 minvalues->Demarshall(&marshalled_dataset);
251 }
252 else _error_("Not supported yet");
253 }
254 else{
255 minvalues=NULL;
256 }
257
258 /*Demarshal maxvalues*/
259 memcpy(&flag,marshalled_dataset,sizeof(int));marshalled_dataset+=sizeof(int);
260 if(flag){
261 memcpy(&input_enum_type,marshalled_dataset,sizeof(int)); marshalled_dataset+=sizeof(int);
262 if(input_enum_type==PentaVertexInputEnum){
263 maxvalues=new PentaVertexInput();
264 maxvalues->Demarshall(&marshalled_dataset);
265 }
266 else if(input_enum_type==TriaVertexInputEnum){
267 maxvalues=new TriaVertexInput();
268 maxvalues->Demarshall(&marshalled_dataset);
269 }
270 else _error_("Not supported yet");
271 }
272 else{
273 maxvalues=NULL;
274 }
275
276 /*Demarshal gradient*/
277 memcpy(&flag,marshalled_dataset,sizeof(int));marshalled_dataset+=sizeof(int);
278 if(flag){
279 memcpy(&input_enum_type,marshalled_dataset,sizeof(int)); marshalled_dataset+=sizeof(int);
280 if(input_enum_type==PentaVertexInputEnum){
281 gradient=new PentaVertexInput();
282 gradient->Demarshall(&marshalled_dataset);
283 }
284 else if(input_enum_type==TriaVertexInputEnum){
285 gradient=new TriaVertexInput();
286 gradient->Demarshall(&marshalled_dataset);
287 }
288 else _error_("Not supported yet");
289 }
290 else{
291 gradient=NULL;
292 }
293
294 /*return: */
295 *pmarshalled_dataset=marshalled_dataset;
296 return;
297}
298/*}}}*/
299#endif
300/*FUNCTION ControlInput::ObjectEnum{{{1*/
301int ControlInput::ObjectEnum(void){
302
303 return ControlInputEnum;
304
305}
306/*}}}*/
307/*FUNCTION ControlInput::copy{{{1*/
308Object* ControlInput::copy() {
309
310 ControlInput* output=NULL;
311
312 output = new ControlInput();
313 output->enum_type=this->enum_type;
314 output->control_id=this->control_id;
315
316 if(values) output->values=(Input*)this->values->copy();
317 if(savedvalues) output->savedvalues=(Input*)this->savedvalues->copy();
318 if(minvalues) output->minvalues=(Input*)this->minvalues->copy();
319 if(maxvalues) output->maxvalues=(Input*)this->maxvalues->copy();
320 if(gradient) output->gradient=(Input*)this->gradient->copy();
321
322 return output;
323}
324/*}}}*/
325
326/*ControlInput management*/
327/*FUNCTION ControlInput::InstanceEnum{{{1*/
328int ControlInput::InstanceEnum(void){
329
330 return this->enum_type;
331
332}
333/*}}}*/
334
335/*Object functions*/
336/*FUNCTION ControlInput::Constrain(){{{1*/
337void ControlInput::Constrain(void){
338
339 Input* newvalues=NULL;
340
341 newvalues=this->values->PointwiseMin(maxvalues);
342 delete values; this->values=newvalues;
343 newvalues=this->values->PointwiseMax(minvalues);
344 delete values; this->values=newvalues;
345}/*}}}*/
346/*FUNCTION ControlInput::Constrain(double min, double max){{{1*/
347void ControlInput::Constrain(double min, double max){
348 values->Constrain(min,max);
349}/*}}}*/
350/*FUNCTION ControlInput::Extrude{{{1*/
351void ControlInput::Extrude(void){
352 values->Extrude();
353 savedvalues->Extrude();
354 //gradient->Extrude();
355}/*}}}*/
356/*FUNCTION ControlInput::GetGradient{{{1*/
357void ControlInput::GetGradient(Vec gradient_vec,int* doflist){
358 if(gradient) gradient->GetVectorFromInputs(gradient_vec,doflist);
359}/*}}}*/
360/*FUNCTION ControlInput::ScaleGradient{{{1*/
361void ControlInput::ScaleGradient(double scaling_factor){
362 if(!gradient) _error_("Gradient of ControlInput %s not found",EnumToStringx(enum_type));
363 gradient->Scale(scaling_factor);
364}/*}}}*/
365/*FUNCTION ControlInput::SetGradient{{{1*/
366void ControlInput::SetGradient(Input* gradient_in){
367
368 /*Get enum for current gradient*/
369 switch(this->control_id){
370 case 1:
371 gradient_in->ChangeEnum(Gradient1Enum);
372 break;
373 case 2:
374 gradient_in->ChangeEnum(Gradient2Enum);
375 break;
376 case 3:
377 gradient_in->ChangeEnum(Gradient3Enum);
378 break;
379 default:
380 _error_("more than 3 controls not implemented yet (Gradient %i was requested). EnumDefinitions.h needs to be updated.",this->control_id);
381 }
382
383 /*Delete old gradient and assign new gradient*/
384 if(gradient) delete gradient;
385 gradient=gradient_in;
386
387}/*}}}*/
388/*FUNCTION ControlInput::SpawnResult{{{1*/
389ElementResult* ControlInput::SpawnResult(int step, double time){
390 return savedvalues->SpawnResult(step,time);
391}/*}}}*/
392/*FUNCTION ControlInput::SpawnTriaInput{{{1*/
393Input* ControlInput::SpawnTriaInput(int* indices){
394 return values->SpawnTriaInput(indices);
395}/*}}}*/
396/*FUNCTION ControlInput::SpawnGradient{{{1*/
397ElementResult* ControlInput::SpawnGradient(int step, double time){
398 return gradient->SpawnResult(step,time);
399}/*}}}*/
400/*FUNCTION ControlInput::GetInputValue(bool* pvalue){{{1*/
401void ControlInput::GetVectorFromInputs(Vec vector,int* doflist){
402 values->GetVectorFromInputs(vector,doflist);
403}/*}}}*/
404/*FUNCTION ControlInput::GetInputAverage(double* pvalue){{{1*/
405void ControlInput::GetInputAverage(double* pvalue){
406 values->GetInputAverage(pvalue);
407}/*}}}*/
408/*FUNCTION ControlInput::GetInputValue(bool* pvalue){{{1*/
409void ControlInput::GetInputValue(bool* pvalue){
410 values->GetInputValue(pvalue);
411}/*}}}*/
412/*FUNCTION ControlInput::GetInputValue(int* pvalue){{{1*/
413void ControlInput::GetInputValue(int* pvalue){
414 values->GetInputValue(pvalue);
415}/*}}}*/
416/*FUNCTION ControlInput::GetInputValue(double* pvalue){{{1*/
417void ControlInput::GetInputValue(double* pvalue){
418 values->GetInputValue(pvalue);
419}/*}}}*/
420/*FUNCTION ControlInput::GetInputValue(double* pvalue){{{1*/
421void ControlInput::GetInputValue(double* pvalue,GaussTria* gauss){
422 values->GetInputValue(pvalue,gauss);
423}/*}}}*/
424/*FUNCTION ControlInput::GetInputValue(double* pvalue){{{1*/
425void ControlInput::GetInputValue(double* pvalue,GaussPenta* gauss){
426 values->GetInputValue(pvalue,gauss);
427}/*}}}*/
428/*FUNCTION ControlInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){{{1*/
429void ControlInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){
430 values->GetInputDerivativeValue(derivativevalues,xyz_list,gauss);
431}/*}}}*/
432/*FUNCTION ControlInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){{{1*/
433void ControlInput::GetInputDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){
434 values->GetInputDerivativeValue(derivativevalues,xyz_list,gauss);
435}/*}}}*/
436/*FUNCTION ControlInput::SaveValue{{{1*/
437void ControlInput::SaveValue(void){
438 if(!values) _error_("Values of %s not found",EnumToStringx(this->enum_type));
439
440 if(savedvalues) delete this->savedvalues;
441 this->savedvalues=(Input*)this->values->copy();
442}/*}}}*/
443/*FUNCTION ControlInput::UpdateValue{{{1*/
444void ControlInput::UpdateValue(double scalar){
445 if(!gradient) _error_("Gradient of %s not found",EnumToStringx(this->enum_type));
446 if(!savedvalues) _error_("Values of %s not found",EnumToStringx(this->enum_type));
447
448 if(values) delete this->values;
449 this->values=(Input*)this->savedvalues->copy();
450 this->values->AXPY(gradient,scalar);
451}/*}}}*/
452/*FUNCTION ControlInput::VerticallyIntegrate{{{1*/
453void ControlInput::VerticallyIntegrate(Input* thickness_input){
454 values->VerticallyIntegrate(thickness_input);
455}/*}}}*/
456/*FUNCTION ControlInput::Configure{{{1*/
457void ControlInput::Configure(Parameters* parameters){
458 /*do nothing: */
459}
460/*}}}*/
Note: See TracBrowser for help on using the repository browser.