source: issm/trunk/src/c/ProcessParamsx/ProcessParamsx.cpp@ 586

Last change on this file since 586 was 586, checked in by Eric.Larour, 16 years ago

Added dakota parallel c code capability + Prognostic capability
File size: 6.2 KB
Line 
1/*!\file ProcessParamsx
2 * \brief: process parameters using partitioning vector
3 */
4
5#include "./ProcessParamsx.h"
6
7#undef __FUNCT__
8#define __FUNCT__ "ProcessParamsx"
9
10#include "../shared/shared.h"
11#include "../include/macros.h"
12#include "../toolkits/toolkits.h"
13#include "../EnumDefinitions/EnumDefinitions.h"
14
15void ProcessParamsx( DataSet* parameters, Vec part){
16
17 int i;
18
19 double* partition=NULL;
20 Param* param=NULL;
21
22 /*diagnostic: */
23 double* vx=NULL;
24 double* vy=NULL;
25 double* vz=NULL;
26 double* pressure=NULL;
27
28 double* u_g=NULL;
29
30 /*control: */
31 Vec vec_vx_obs=NULL;
32 Vec vec_vy_obs=NULL;
33 Vec vec_control_parameter=NULL;
34
35 double* vx_obs=NULL;
36 double* vy_obs=NULL;
37 double* control_parameter=NULL;
38
39 double* u_g_obs=NULL;
40 double* p_g=NULL;
41
42 /*prognostic: */
43 double* a_g=NULL;
44 double* m_g=NULL;
45 double* h_g=NULL;
46 double* accumulation=NULL;
47 double* thickness=NULL;
48 double* melting=NULL;
49
50
51 /*diverse: */
52 int numberofnodes;
53 int analysis_type;
54 int count;
55
56 parameters->FindParam((void*)&analysis_type,"analysis_type");
57 count=parameters->Size();
58
59 parameters->FindParam((void*)&numberofnodes,"numberofnodes");
60
61 /*First serialize partition vector: */
62 if(part)VecToMPISerial(&partition,part);
63
64
65 if ( (analysis_type==ControlAnalysisEnum()) ||
66 (analysis_type==DiagnosticAnalysisEnum()) ||
67 (analysis_type==ThermalAnalysisEnum()) ||
68 (analysis_type==PrognosticAnalysisEnum())
69 ){
70
71 parameters->FindParam((void*)&vx,"vx");
72 parameters->FindParam((void*)&vy,"vy");
73 parameters->FindParam((void*)&vz,"vz");
74
75 if(numberofnodes){
76 u_g=(double*)xcalloc(numberofnodes*3,sizeof(double));
77
78 if(vx){
79 for(i=0;i<numberofnodes;i++){
80 u_g[(int)(3*partition[i]+0)]=vx[i];
81 }
82 }
83
84 if(vy){
85 for(i=0;i<numberofnodes;i++){
86 u_g[(int)(3*partition[i]+1)]=vy[i];
87 }
88 }
89 if(vz){
90 for(i=0;i<numberofnodes;i++){
91 u_g[(int)(3*partition[i]+2)]=vz[i];
92 }
93 }
94
95
96 /*Now, create new parameters: */
97 count++;
98 param= new Param(count,"u_g",DOUBLEVEC);
99 param->SetDoubleVec(u_g,3*numberofnodes);
100 parameters->AddObject(param);
101
102 /*erase old parameters: */
103 param=(Param*)parameters->FindParamObject("vx");
104 parameters->DeleteObject((Object*)param);
105
106 param=(Param*)parameters->FindParamObject("vy");
107 parameters->DeleteObject((Object*)param);
108
109 param=(Param*)parameters->FindParamObject("vz");
110 parameters->DeleteObject((Object*)param);
111 }
112
113 }
114
115
116 if(analysis_type==ControlAnalysisEnum()){
117
118 parameters->FindParam((void*)&vx_obs,"vx_obs");
119 parameters->FindParam((void*)&vy_obs,"vy_obs");
120 parameters->FindParam((void*)&control_parameter,"control_parameter");
121
122 /*Now, from vx_obs and vy_obs, build u_g_obs, correctly partitioned: */
123
124 u_g_obs=(double*)xcalloc(numberofnodes*2,sizeof(double));
125 p_g=(double*)xcalloc(numberofnodes*2,sizeof(double));
126
127 for(i=0;i<numberofnodes;i++){
128 u_g_obs[(int)(2*partition[i]+0)]=vx_obs[i];
129 u_g_obs[(int)(2*partition[i]+1)]=vy_obs[i];
130 p_g[(int)(2*partition[i]+0)]=control_parameter[i];
131 }
132
133 /*Now, create new parameters: */
134 count++;
135 param= new Param(count,"u_g_obs",DOUBLEVEC);
136 param->SetDoubleVec(u_g_obs,2*numberofnodes);
137 parameters->AddObject(param);
138
139 count++;
140 param= new Param(count,"p_g",DOUBLEVEC);
141 param->SetDoubleVec(p_g,2*numberofnodes);
142 parameters->AddObject(param);
143
144 /*erase old parameter: */
145 param=(Param*)parameters->FindParamObject("vx_obs");
146 parameters->DeleteObject((Object*)param);
147
148 param=(Param*)parameters->FindParamObject("vy_obs");
149 parameters->DeleteObject((Object*)param);
150
151 param=(Param*)parameters->FindParamObject("control_parameter");
152 parameters->DeleteObject((Object*)param);
153
154 }
155
156 if(analysis_type==ThermalAnalysisEnum()){
157
158 parameters->FindParam((void*)&pressure,"pressure");
159
160 /*Now, from pressure, build p_g, correctly partitioned: */
161 p_g=(double*)xcalloc(numberofnodes,sizeof(double));
162
163 for(i=0;i<numberofnodes;i++){
164 p_g[(int)(partition[i])]= pressure[i];
165 }
166
167 /*Now, create new parameter: */
168 count++;
169 param= new Param(count,"p_g",DOUBLEVEC);
170 param->SetDoubleVec(p_g,numberofnodes);
171 parameters->AddObject(param);
172
173 /*erase old parameter: */
174 param=(Param*)parameters->FindParamObject("pressure");
175 parameters->DeleteObject((Object*)param);
176 }
177
178 if(analysis_type==PrognosticAnalysisEnum()){
179
180 parameters->FindParam((void*)&melting,"melting");
181
182 /*Now, from melting, build m_g, correctly partitioned: */
183 m_g=(double*)xcalloc(numberofnodes,sizeof(double));
184
185 for(i=0;i<numberofnodes;i++){
186 m_g[(int)(partition[i])]= melting[i];
187 }
188
189 /*Now, create new parameter: */
190 count++;
191 param= new Param(count,"m_g",DOUBLEVEC);
192 param->SetDoubleVec(m_g,numberofnodes);
193 parameters->AddObject(param);
194
195 /*erase old parameter: */
196 param=(Param*)parameters->FindParamObject("melting");
197 parameters->DeleteObject((Object*)param);
198
199
200
201 parameters->FindParam((void*)&thickness,"thickness");
202
203 /*Now, from thickness, build h_g, correctly partitioned: */
204 h_g=(double*)xcalloc(numberofnodes,sizeof(double));
205
206 for(i=0;i<numberofnodes;i++){
207 h_g[(int)(partition[i])]= thickness[i];
208 }
209
210 /*Now, create new parameter: */
211 count++;
212 param= new Param(count,"h_g",DOUBLEVEC);
213 param->SetDoubleVec(h_g,numberofnodes);
214 parameters->AddObject(param);
215
216 /*erase old parameter: */
217 param=(Param*)parameters->FindParamObject("thickness");
218 parameters->DeleteObject((Object*)param);
219
220
221
222
223 parameters->FindParam((void*)&accumulation,"accumulation");
224
225 /*Now, from accumulation, build a_g, correctly partitioned: */
226 a_g=(double*)xcalloc(numberofnodes,sizeof(double));
227
228 for(i=0;i<numberofnodes;i++){
229 a_g[(int)(partition[i])]= accumulation[i];
230 }
231
232 /*Now, create new parameter: */
233 count++;
234 param= new Param(count,"a_g",DOUBLEVEC);
235 param->SetDoubleVec(a_g,numberofnodes);
236 parameters->AddObject(param);
237
238 /*erase old parameter: */
239 param=(Param*)parameters->FindParamObject("accumulation");
240 parameters->DeleteObject((Object*)param);
241
242
243
244 }
245 xfree((void**)&partition);
246
247 xfree((void**)&vx);
248 xfree((void**)&vy);
249 xfree((void**)&vz);
250 xfree((void**)&u_g);
251
252 xfree((void**)&vx_obs);
253 xfree((void**)&vy_obs);
254 xfree((void**)&pressure);
255 xfree((void**)&control_parameter);
256 xfree((void**)&u_g_obs);
257 xfree((void**)&p_g);
258 xfree((void**)&a_g);
259 xfree((void**)&h_g);
260 xfree((void**)&m_g);
261
262}
Note: See TracBrowser for help on using the repository browser.