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

Last change on this file since 6200 was 6200, checked in by Mathieu Morlighem, 14 years ago

New class ControlInput used in controlmethods
File size: 10.2 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 values =NULL;
23 savedvalues =NULL;
24 gradient =NULL;
25}
26/*}}}*/
27/*FUNCTION ControlInput::ControlInput(int enum_type,int enum_input,double* pvalues){{{1*/
28ControlInput::ControlInput(int in_enum_type,int enum_input,double* pvalues){
29 enum_type=in_enum_type;
30 switch(enum_input){
31 case TriaVertexInputEnum:
32 values =new TriaVertexInput(enum_type,pvalues);
33 savedvalues=new TriaVertexInput(enum_type,pvalues);
34 break;
35 case PentaVertexInputEnum:
36 values =new PentaVertexInput(enum_type,pvalues);
37 savedvalues=new PentaVertexInput(enum_type,pvalues);
38 break;
39 default:
40 ISSMERROR("Input of Enum %s not supported yet by ControlInput",EnumToString(enum_input));
41 }
42 gradient =NULL;
43}
44/*}}}*/
45/*FUNCTION ControlInput::~ControlInput(){{{1*/
46ControlInput::~ControlInput(){
47 delete values;
48 delete savedvalues;
49 delete gradient;
50}
51/*}}}*/
52
53/*Object virtual functions definitions:*/
54 /*FUNCTION ControlInput::Echo {{{1*/
55void ControlInput::Echo(void){
56 this->DeepEcho();
57}
58/*}}}*/
59/*FUNCTION ControlInput::DeepEcho{{{1*/
60void ControlInput::DeepEcho(void){
61
62 printf("ControlInput:\n");
63 printf(" enum: %i (%s)\n",this->enum_type,EnumToString(this->enum_type));
64 printf("---values: \n"); if (values) values->Echo();
65 printf("---savedvalues: \n"); if (savedvalues) savedvalues->Echo();
66 printf("---gradient: \n"); if (gradient) gradient->Echo();
67}
68/*}}}*/
69/*FUNCTION ControlInput::Id{{{1*/
70int ControlInput::Id(void){ return -1; }
71/*}}}*/
72/*FUNCTION ControlInput::MyRank{{{1*/
73int ControlInput::MyRank(void){
74 extern int my_rank;
75 return my_rank;
76}
77/*}}}*/
78/*FUNCTION ControlInput::Marshall{{{1*/
79void ControlInput::Marshall(char** pmarshalled_dataset){
80
81 char* marshalled_dataset=NULL;
82 int enum_value=0;
83 int flag;
84
85 /*recover marshalled_dataset: */
86 marshalled_dataset=*pmarshalled_dataset;
87
88 /*get enum value of ControlInput: */
89 enum_value=ControlInputEnum;
90
91 /*marshall enum: */
92 memcpy(marshalled_dataset,&enum_value,sizeof(enum_value));marshalled_dataset+=sizeof(enum_value);
93
94 /*marshall enum_type: */
95 memcpy(marshalled_dataset,&enum_type,sizeof(enum_type));marshalled_dataset+=sizeof(enum_type);
96
97 /*marshal values*/
98 if(!values){
99 flag=0;
100 memcpy(marshalled_dataset,&flag,sizeof(flag));marshalled_dataset+=sizeof(flag);
101 }
102 else{
103 flag=1;
104 memcpy(marshalled_dataset,&flag,sizeof(flag));marshalled_dataset+=sizeof(flag);
105 this->values->Marshall(&marshalled_dataset);
106 }
107
108 /*marshal savedvalues*/
109 if(!savedvalues){
110 flag=0;
111 memcpy(marshalled_dataset,&flag,sizeof(flag));marshalled_dataset+=sizeof(flag);
112 }
113 else{
114 flag=1;
115 memcpy(marshalled_dataset,&flag,sizeof(flag));marshalled_dataset+=sizeof(flag);
116 this->savedvalues->Marshall(&marshalled_dataset);
117 }
118
119 /*marshal gradient*/
120 if(!gradient){
121 flag=0;
122 memcpy(marshalled_dataset,&flag,sizeof(flag));marshalled_dataset+=sizeof(flag);
123 }
124 else{
125 flag=1;
126 memcpy(marshalled_dataset,&flag,sizeof(flag));marshalled_dataset+=sizeof(flag);
127 this->gradient->Marshall(&marshalled_dataset);
128 }
129
130 /*clean up and assign output pointer*/
131 *pmarshalled_dataset=marshalled_dataset;
132}
133/*}}}*/
134/*FUNCTION ControlInput::MarshallSize{{{1*/
135int ControlInput::MarshallSize(){
136
137 int size=0;
138
139 size=sizeof(enum_type)+
140 +3*sizeof(int) //3 flags
141 +sizeof(int); //sizeof(int) for enum value
142
143 if(values) size+=values->MarshallSize();
144 if(savedvalues)size+=savedvalues->MarshallSize();
145 if(gradient) size+=gradient->MarshallSize();
146 return size;
147}
148/*}}}*/
149/*FUNCTION ControlInput::Demarshall{{{1*/
150void ControlInput::Demarshall(char** pmarshalled_dataset){
151
152 char* marshalled_dataset=NULL;
153 int flag,input_enum_type;
154
155 /*recover marshalled_dataset: */
156 marshalled_dataset=*pmarshalled_dataset;
157
158 /*this time, no need to get enum type, the pointer directly points to the beginning of the
159 *object data (thanks to DataSet::Demarshall):*/
160 memcpy(&enum_type,marshalled_dataset,sizeof(enum_type));marshalled_dataset+=sizeof(enum_type);
161
162 /*Demarshal values*/
163 memcpy(&flag,marshalled_dataset,sizeof(int));marshalled_dataset+=sizeof(int);
164 if(flag){
165 memcpy(&input_enum_type,marshalled_dataset,sizeof(int)); marshalled_dataset+=sizeof(int);
166 if(input_enum_type==PentaVertexInputEnum){
167 values=new PentaVertexInput();
168 values->Demarshall(&marshalled_dataset);
169 }
170 else if(input_enum_type==TriaVertexInputEnum){
171 values=new TriaVertexInput();
172 values->Demarshall(&marshalled_dataset);
173 }
174 else ISSMERROR("Not supported yet");
175 }
176 else{
177 values=NULL;
178 }
179
180 /*Demarshal savedvalues*/
181 memcpy(&flag,marshalled_dataset,sizeof(int));marshalled_dataset+=sizeof(int);
182 if(flag){
183 memcpy(&input_enum_type,marshalled_dataset,sizeof(int)); marshalled_dataset+=sizeof(int);
184 if(input_enum_type==PentaVertexInputEnum){
185 savedvalues=new PentaVertexInput();
186 savedvalues->Demarshall(&marshalled_dataset);
187 }
188 else if(input_enum_type==TriaVertexInputEnum){
189 savedvalues=new TriaVertexInput();
190 savedvalues->Demarshall(&marshalled_dataset);
191 }
192 else ISSMERROR("Not supported yet");
193 }
194 else{
195 savedvalues=NULL;
196 }
197
198 /*Demarshal gradient*/
199 memcpy(&flag,marshalled_dataset,sizeof(int));marshalled_dataset+=sizeof(int);
200 if(flag){
201 memcpy(&input_enum_type,marshalled_dataset,sizeof(int)); marshalled_dataset+=sizeof(int);
202 if(input_enum_type==PentaVertexInputEnum){
203 gradient=new PentaVertexInput();
204 gradient->Demarshall(&marshalled_dataset);
205 }
206 else if(input_enum_type==TriaVertexInputEnum){
207 gradient=new TriaVertexInput();
208 gradient->Demarshall(&marshalled_dataset);
209 }
210 else ISSMERROR("Not supported yet");
211 }
212 else{
213 gradient=NULL;
214 }
215
216 /*return: */
217 *pmarshalled_dataset=marshalled_dataset;
218 return;
219}
220/*}}}*/
221/*FUNCTION ControlInput::Enum{{{1*/
222int ControlInput::Enum(void){
223
224 return ControlInputEnum;
225
226}
227/*}}}*/
228/*FUNCTION ControlInput::copy{{{1*/
229Object* ControlInput::copy() {
230
231 ControlInput* output=NULL;
232
233 output = new ControlInput();
234 output->enum_type=this->enum_type;
235
236 if(values) output->values=(Input*)this->values->copy();
237 if(savedvalues) output->savedvalues=(Input*)this->savedvalues->copy();
238 if(gradient) output->gradient=(Input*)this->gradient->copy();
239
240 return output;
241}
242/*}}}*/
243
244/*ControlInput management*/
245/*FUNCTION ControlInput::EnumType{{{1*/
246int ControlInput::EnumType(void){
247
248 return this->enum_type;
249
250}
251/*}}}*/
252
253/*Object functions*/
254/*FUNCTION ControlInput::Constrain{{{1*/
255void ControlInput::Constrain(double cm_min, double cm_max){
256 values->Constrain(cm_min,cm_max);
257}/*}}}*/
258/*FUNCTION ControlInput::Extrude{{{1*/
259void ControlInput::Extrude(void){
260 values->Extrude();
261 savedvalues->Extrude();
262 //gradient->Extrude();
263}/*}}}*/
264/*FUNCTION ControlInput::GetGradient{{{1*/
265void ControlInput::GetGradient(Vec gradient_vec,int* doflist){
266 if(gradient) gradient->GetVectorFromInputs(gradient_vec,doflist);
267}/*}}}*/
268/*FUNCTION ControlInput::SetGradient{{{1*/
269void ControlInput::SetGradient(Input* gradient_in){
270 if(gradient) delete gradient;
271 gradient=gradient_in;
272}/*}}}*/
273/*FUNCTION ControlInput::SpawnResult{{{1*/
274ElementResult* ControlInput::SpawnResult(int step, double time){
275 return savedvalues->SpawnResult(step,time);
276}/*}}}*/
277/*FUNCTION ControlInput::SpawnTriaInput{{{1*/
278Input* ControlInput::SpawnTriaInput(int* indices){
279 return values->SpawnTriaInput(indices);
280}/*}}}*/
281/*FUNCTION ControlInput::SpawnGradient{{{1*/
282ElementResult* ControlInput::SpawnGradient(int step, double time){
283 gradient->SpawnResult(step,time);
284}/*}}}*/
285/*FUNCTION ControlInput::GetParameterAverage(double* pvalue){{{1*/
286void ControlInput::GetParameterAverage(double* pvalue){
287 values->GetParameterAverage(pvalue);
288}/*}}}*/
289/*FUNCTION ControlInput::GetParameterValue(bool* pvalue){{{1*/
290void ControlInput::GetParameterValue(bool* pvalue){
291 values->GetParameterValue(pvalue);
292}/*}}}*/
293/*FUNCTION ControlInput::GetParameterValue(int* pvalue){{{1*/
294void ControlInput::GetParameterValue(int* pvalue){
295 values->GetParameterValue(pvalue);
296}/*}}}*/
297/*FUNCTION ControlInput::GetParameterValue(double* pvalue){{{1*/
298void ControlInput::GetParameterValue(double* pvalue){
299 values->GetParameterValue(pvalue);
300}/*}}}*/
301/*FUNCTION ControlInput::GetParameterValue(double* pvalue){{{1*/
302void ControlInput::GetParameterValue(double* pvalue,GaussTria* gauss){
303 values->GetParameterValue(pvalue,gauss);
304}/*}}}*/
305/*FUNCTION ControlInput::GetParameterValue(double* pvalue){{{1*/
306void ControlInput::GetParameterValue(double* pvalue,GaussPenta* gauss){
307 values->GetParameterValue(pvalue,gauss);
308}/*}}}*/
309/*FUNCTION ControlInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){{{1*/
310void ControlInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){
311 values->GetParameterDerivativeValue(derivativevalues,xyz_list,gauss);
312}/*}}}*/
313/*FUNCTION ControlInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){{{1*/
314void ControlInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){
315 values->GetParameterDerivativeValue(derivativevalues,xyz_list,gauss);
316}/*}}}*/
317/*FUNCTION ControlInput::SaveValue{{{1*/
318void ControlInput::SaveValue(void){
319 if(!values) ISSMERROR("Values of %s not found",EnumToString(this->enum_type));
320
321 if(savedvalues) delete this->savedvalues;
322 this->savedvalues=(Input*)this->values->copy();
323}/*}}}*/
324/*FUNCTION ControlInput::UpdateValue{{{1*/
325void ControlInput::UpdateValue(double scalar){
326 if(!gradient) ISSMERROR("Gradient of %s not found",EnumToString(this->enum_type));
327 if(!savedvalues) ISSMERROR("Values of %s not found",EnumToString(this->enum_type));
328
329 if(values) delete this->values;
330 this->values=(Input*)this->savedvalues->copy();
331 this->values->AXPY(gradient,scalar);
332}/*}}}*/
333/*FUNCTION ControlInput::VerticallyIntegrate{{{1*/
334void ControlInput::VerticallyIntegrate(Input* thickness_input){
335 values->VerticallyIntegrate(thickness_input);
336}/*}}}*/
Note: See TracBrowser for help on using the repository browser.