source: issm/branches/trunk-larour-SLPS2022/src/c/modules/ModelProcessorx/CreateOutputDefinitions.cpp@ 27220

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

CHG: fixing simple leaks.
File size: 40.3 KB
Line 
1/*!\file: CreateParametersOutputDefinitions.cpp
2 * \brief driver for creating output definitions dataset, and including it into the parameters dataset
3 */
4
5#include "../../toolkits/toolkits.h"
6#include "../../classes/classes.h"
7#include "../../shared/shared.h"
8#include "./ModelProcessorx.h"
9
10void CreateOutputDefinitions(Elements* elements,Parameters* parameters,Inputs* inputs,IoModel* iomodel){
11
12 int i,j;
13
14 DataSet* output_definitions = NULL;
15 int* output_definition_enums = NULL;
16 int num_output_definitions;
17
18 /*Create output_definitions dataset: */
19 output_definitions=new DataSet();
20 char** out_strings = NULL;
21 iomodel->FetchData(&out_strings,&num_output_definitions,"md.outputdefinition.list");
22 if(num_output_definitions>0){
23 output_definition_enums=xNew<int>(num_output_definitions);
24 for(int i=0;i<num_output_definitions;i++){
25 output_definition_enums[i]=StringToEnumx(out_strings[i]);
26 }
27 }
28 // free data:
29 for(int i=0;i<num_output_definitions;i++) xDelete<char>(out_strings[i]);
30 xDelete<char*>(out_strings);
31
32 if(num_output_definitions){
33 for (i=0;i<num_output_definitions;i++){
34 if (output_definition_enums[i]==MassfluxatgateEnum){
35 /*Deal with mass flux gates:{{{ */
36
37 /*massfluxatgate variables: */
38 int temp,numgates;
39 char **gatenames = NULL;
40 char **gatedefinitionstrings = NULL;
41 IssmDouble **gatesegments = NULL;
42 int *gatesegments_M = NULL;
43
44 /*Fetch segments and names: */
45 iomodel->FetchMultipleData(&gatenames,&numgates, "md.massfluxatgate.name");
46 iomodel->FetchMultipleData(&gatedefinitionstrings,&temp, "md.massfluxatgate.definitionstring"); _assert_(temp==numgates);
47 iomodel->FetchMultipleData(&gatesegments,&gatesegments_M,NULL,&temp, "md.massfluxatgate.segments"); _assert_(temp==numgates);
48
49 for(j=0;j<numgates;j++){
50 output_definitions->AddObject(new Massfluxatgate<IssmDouble>(gatenames[j],StringToEnumx(gatedefinitionstrings[j]),gatesegments_M[j],gatesegments[j]));
51 }
52 /*Free ressources:*/
53 for(j=0;j<numgates;j++){
54 char* string = gatenames[j]; xDelete<char>(string);
55 char* string2 = gatedefinitionstrings[j]; xDelete<char>(string2);
56 IssmDouble* gate = gatesegments[j]; xDelete<IssmDouble>(gate);
57 }
58 xDelete<char*>(gatenames);
59 xDelete<IssmDouble*>(gatesegments);
60 xDelete<int>(gatesegments_M);
61 xDelete<char*>(gatedefinitionstrings);
62 /*}}}*/
63 }
64 else if (output_definition_enums[i]==MisfitEnum){
65 /*Deal with misfits: {{{*/
66
67 /*misfit variables: */
68 int nummisfits;
69 char** misfit_name_s = NULL;
70 char** misfit_definitionstring_s = NULL;
71 char** misfit_model_string_s = NULL;
72 IssmDouble** misfit_observation_s = NULL;
73 char** misfit_observation_string_s = NULL;
74 int* misfit_observation_M_s = NULL;
75 int* misfit_observation_N_s = NULL;
76 int* misfit_local_s = NULL;
77 char** misfit_timeinterpolation_s = NULL;
78 IssmDouble** misfit_weights_s = NULL;
79 int* misfit_weights_M_s = NULL;
80 int* misfit_weights_N_s = NULL;
81 char** misfit_weights_string_s = NULL;
82
83 /*Fetch name, model_string, observation, observation_string, etc ... (see src/m/classes/misfit.m): */
84 iomodel->FetchMultipleData(&misfit_name_s,&nummisfits, "md.misfit.name");
85 iomodel->FetchMultipleData(&misfit_definitionstring_s,&nummisfits, "md.misfit.definitionstring");
86 iomodel->FetchMultipleData(&misfit_model_string_s,&nummisfits, "md.misfit.model_string");
87 iomodel->FetchMultipleData(&misfit_observation_s,&misfit_observation_M_s,&misfit_observation_N_s,&nummisfits, "md.misfit.observation");
88 iomodel->FetchMultipleData(&misfit_observation_string_s,&nummisfits, "md.misfit.observation_string");
89 iomodel->FetchMultipleData(&misfit_timeinterpolation_s,&nummisfits, "md.misfit.timeinterpolation");
90 iomodel->FetchMultipleData(&misfit_local_s,&nummisfits, "md.misfit.local");
91 iomodel->FetchMultipleData(&misfit_weights_s,&misfit_weights_M_s,&misfit_weights_N_s,&nummisfits, "md.misfit.weights");
92 iomodel->FetchMultipleData(&misfit_weights_string_s,&nummisfits, "md.misfit.weights_string");
93
94 for(j=0;j<nummisfits;j++){
95
96 int obs_vector_type=0;
97 if ((misfit_observation_M_s[j]==iomodel->numberofvertices) || (misfit_observation_M_s[j]==iomodel->numberofvertices+1)){
98 obs_vector_type=1;
99 }
100 else if ((misfit_observation_M_s[j]==iomodel->numberofelements) || (misfit_observation_M_s[j]==iomodel->numberofelements+1)){
101 obs_vector_type=2;
102 }
103 else
104 _error_("misfit observation size not supported yet");
105
106 int weight_vector_type=0;
107 if ((misfit_weights_M_s[j]==iomodel->numberofvertices) || (misfit_weights_M_s[j]==iomodel->numberofvertices+1)){
108 weight_vector_type=1;
109 }
110 else if ((misfit_weights_M_s[j]==iomodel->numberofelements) || (misfit_weights_M_s[j]==iomodel->numberofelements+1)){
111 weight_vector_type=2;
112 }
113 else
114 _error_("misfit weight size not supported yet");
115
116 /*First create a misfit object for that specific string (misfit_model_string_s[j]):*/
117 output_definitions->AddObject(new Misfit(misfit_name_s[j],StringToEnumx(misfit_definitionstring_s[j]),StringToEnumx(misfit_model_string_s[j]),StringToEnumx(misfit_observation_string_s[j]),misfit_timeinterpolation_s[j],misfit_local_s[j],StringToEnumx(misfit_weights_string_s[j])));
118
119 /*Now, for this particular misfit object, make sure we plug into the elements: the observation, and the weights.*/
120 for(Object* & object : elements->objects){
121 Element* element=xDynamicCast<Element*>(object);
122 element->InputCreate(misfit_observation_s[j],inputs,iomodel,misfit_observation_M_s[j],misfit_observation_N_s[j],obs_vector_type,StringToEnumx(misfit_observation_string_s[j]),7);
123 element->InputCreate(misfit_weights_s[j],inputs,iomodel,misfit_weights_M_s[j],misfit_weights_N_s[j],weight_vector_type,StringToEnumx(misfit_weights_string_s[j]),7);
124 }
125
126 }
127
128 /*Free ressources:*/
129 for(j=0;j<nummisfits;j++){
130 char* string=NULL;
131 IssmDouble* matrix = NULL;
132 string = misfit_definitionstring_s[j]; xDelete<char>(string);
133 string = misfit_observation_string_s[j]; xDelete<char>(string);
134 string = misfit_model_string_s[j]; xDelete<char>(string);
135 string = misfit_weights_string_s[j]; xDelete<char>(string);
136 string = misfit_name_s[j]; xDelete<char>(string);
137 string = misfit_timeinterpolation_s[j]; xDelete<char>(string);
138 matrix = misfit_observation_s[j]; xDelete<IssmDouble>(matrix);
139 matrix = misfit_weights_s[j]; xDelete<IssmDouble>(matrix);
140 }
141 xDelete<char*>(misfit_name_s);
142 xDelete<char*>(misfit_model_string_s);
143 xDelete<char*>(misfit_definitionstring_s);
144 xDelete<IssmDouble*>(misfit_observation_s);
145 xDelete<char*>(misfit_observation_string_s);
146 xDelete<int>(misfit_observation_M_s);
147 xDelete<int>(misfit_observation_N_s);
148 xDelete<int>(misfit_local_s);
149 xDelete<char*>(misfit_timeinterpolation_s);
150 xDelete<IssmDouble*>(misfit_weights_s);
151 xDelete<int>(misfit_weights_M_s);
152 xDelete<int>(misfit_weights_N_s);
153 xDelete<char*>(misfit_weights_string_s);
154 /*}}}*/
155 }
156 else if (output_definition_enums[i]==CfsurfacesquareEnum){
157 /*Deal with cfsurfacesquare: {{{*/
158
159 /*cfsurfacesquare variables: */
160 int num_cfsurfacesquares;
161 char** cfsurfacesquare_name_s = NULL;
162 char** cfsurfacesquare_definitionstring_s = NULL;
163 char** cfsurfacesquare_model_string_s = NULL;
164 IssmDouble** cfsurfacesquare_observation_s = NULL;
165 char** cfsurfacesquare_observation_string_s = NULL;
166 int* cfsurfacesquare_observation_M_s = NULL;
167 int* cfsurfacesquare_observation_N_s = NULL;
168 IssmDouble** cfsurfacesquare_weights_s = NULL;
169 int* cfsurfacesquare_weights_M_s = NULL;
170 int* cfsurfacesquare_weights_N_s = NULL;
171 char** cfsurfacesquare_weights_string_s = NULL;
172 IssmDouble* cfsurfacesquare_datatime_s = NULL;
173
174 /*Fetch name, model_string, observation, observation_string, etc ... (see src/m/classes/cfsurfacesquare.m): */
175 iomodel->FetchMultipleData(&cfsurfacesquare_name_s,&num_cfsurfacesquares, "md.cfsurfacesquare.name");
176 iomodel->FetchMultipleData(&cfsurfacesquare_definitionstring_s,&num_cfsurfacesquares, "md.cfsurfacesquare.definitionstring");
177 iomodel->FetchMultipleData(&cfsurfacesquare_model_string_s,&num_cfsurfacesquares, "md.cfsurfacesquare.model_string");
178 iomodel->FetchMultipleData(&cfsurfacesquare_observation_s,&cfsurfacesquare_observation_M_s,&cfsurfacesquare_observation_N_s,&num_cfsurfacesquares, "md.cfsurfacesquare.observation");
179 iomodel->FetchMultipleData(&cfsurfacesquare_observation_string_s,&num_cfsurfacesquares, "md.cfsurfacesquare.observation_string");
180 iomodel->FetchMultipleData(&cfsurfacesquare_weights_s,&cfsurfacesquare_weights_M_s,&cfsurfacesquare_weights_N_s,&num_cfsurfacesquares, "md.cfsurfacesquare.weights");
181 iomodel->FetchMultipleData(&cfsurfacesquare_weights_string_s,&num_cfsurfacesquares, "md.cfsurfacesquare.weights_string");
182 iomodel->FetchMultipleData(&cfsurfacesquare_datatime_s,&num_cfsurfacesquares, "md.cfsurfacesquare.datatime");
183
184 for(j=0;j<num_cfsurfacesquares;j++){
185
186 int obs_vector_type=0;
187 if ((cfsurfacesquare_observation_M_s[j]==iomodel->numberofvertices) || (cfsurfacesquare_observation_M_s[j]==iomodel->numberofvertices+1)){
188 obs_vector_type=1;
189 }
190 else if ((cfsurfacesquare_observation_M_s[j]==iomodel->numberofelements) || (cfsurfacesquare_observation_M_s[j]==iomodel->numberofelements+1)){
191 obs_vector_type=2;
192 }
193 else
194 _error_("cfsurfacesquare observation size not supported yet");
195
196 int weight_vector_type=0;
197 if ((cfsurfacesquare_weights_M_s[j]==iomodel->numberofvertices) || (cfsurfacesquare_weights_M_s[j]==iomodel->numberofvertices+1)){
198 weight_vector_type=1;
199 }
200 else if ((cfsurfacesquare_weights_M_s[j]==iomodel->numberofelements) || (cfsurfacesquare_weights_M_s[j]==iomodel->numberofelements+1)){
201 weight_vector_type=2;
202 }
203 else
204 _error_("cfsurfacesquare weight size not supported yet");
205
206 /*First create a cfsurfacesquare object for that specific string (cfsurfacesquare_model_string_s[j]):*/
207 output_definitions->AddObject(new Cfsurfacesquare(cfsurfacesquare_name_s[j],StringToEnumx(cfsurfacesquare_definitionstring_s[j]),StringToEnumx(cfsurfacesquare_model_string_s[j]),StringToEnumx(cfsurfacesquare_observation_string_s[j]),StringToEnumx(cfsurfacesquare_weights_string_s[j]),cfsurfacesquare_datatime_s[j],false));
208
209 /*Now, for this particular cfsurfacesquare object, make sure we plug into the elements: the observation, and the weights.*/
210 for(Object* & object : elements->objects){
211 Element* element=xDynamicCast<Element*>(object);
212 element->DatasetInputAdd(StringToEnumx(cfsurfacesquare_definitionstring_s[j]),cfsurfacesquare_observation_s[j],inputs,iomodel,cfsurfacesquare_observation_M_s[j],cfsurfacesquare_observation_N_s[j],obs_vector_type,StringToEnumx(cfsurfacesquare_observation_string_s[j]),7,SurfaceObservationEnum);
213 element->DatasetInputAdd(StringToEnumx(cfsurfacesquare_definitionstring_s[j]),cfsurfacesquare_weights_s[j],inputs,iomodel,cfsurfacesquare_weights_M_s[j],cfsurfacesquare_weights_N_s[j],weight_vector_type,StringToEnumx(cfsurfacesquare_weights_string_s[j]),7,WeightsSurfaceObservationEnum);
214
215 }
216
217 }
218
219 /*Free ressources:*/
220 for(j=0;j<num_cfsurfacesquares;j++){
221 char* string=NULL;
222 IssmDouble* matrix = NULL;
223
224 string = cfsurfacesquare_definitionstring_s[j]; xDelete<char>(string);
225 string = cfsurfacesquare_observation_string_s[j]; xDelete<char>(string);
226 string = cfsurfacesquare_model_string_s[j]; xDelete<char>(string);
227 string = cfsurfacesquare_weights_string_s[j]; xDelete<char>(string);
228 string = cfsurfacesquare_name_s[j]; xDelete<char>(string);
229 matrix = cfsurfacesquare_observation_s[j]; xDelete<IssmDouble>(matrix);
230 matrix = cfsurfacesquare_weights_s[j]; xDelete<IssmDouble>(matrix);
231 }
232 xDelete<char*>(cfsurfacesquare_name_s);
233 xDelete<char*>(cfsurfacesquare_model_string_s);
234 xDelete<char*>(cfsurfacesquare_definitionstring_s);
235 xDelete<IssmDouble*>(cfsurfacesquare_observation_s);
236 xDelete<char*>(cfsurfacesquare_observation_string_s);
237 xDelete<int>(cfsurfacesquare_observation_M_s);
238 xDelete<int>(cfsurfacesquare_observation_N_s);
239 xDelete<IssmDouble*>(cfsurfacesquare_weights_s);
240 xDelete<int>(cfsurfacesquare_weights_M_s);
241 xDelete<int>(cfsurfacesquare_weights_N_s);
242 xDelete<char*>(cfsurfacesquare_weights_string_s);
243 xDelete<IssmDouble>(cfsurfacesquare_datatime_s);
244 /*}}}*/
245 }
246 else if (output_definition_enums[i]==CfdragcoeffabsgradEnum){
247 /*Deal with cfdragcoeffabsgrad: {{{*/
248
249 /*cfdragcoeffabsgrad variables: */
250 int num_cfdragcoeffabsgrads;
251 char** cfdragcoeffabsgrad_name_s = NULL;
252 char** cfdragcoeffabsgrad_definitionstring_s = NULL;
253 IssmDouble** cfdragcoeffabsgrad_weights_s = NULL;
254 int* cfdragcoeffabsgrad_weights_M_s = NULL;
255 int* cfdragcoeffabsgrad_weights_N_s = NULL;
256 char** cfdragcoeffabsgrad_weights_string_s = NULL;
257
258 /*Fetch name, model_string, observation, observation_string, etc ... (see src/m/classes/cfdragcoeffabsgrad.m): */
259 iomodel->FetchMultipleData(&cfdragcoeffabsgrad_name_s,&num_cfdragcoeffabsgrads, "md.cfdragcoeffabsgrad.name");
260 iomodel->FetchMultipleData(&cfdragcoeffabsgrad_definitionstring_s,&num_cfdragcoeffabsgrads, "md.cfdragcoeffabsgrad.definitionstring");
261 iomodel->FetchMultipleData(&cfdragcoeffabsgrad_weights_s,&cfdragcoeffabsgrad_weights_M_s,&cfdragcoeffabsgrad_weights_N_s,&num_cfdragcoeffabsgrads, "md.cfdragcoeffabsgrad.weights");
262 iomodel->FetchMultipleData(&cfdragcoeffabsgrad_weights_string_s,&num_cfdragcoeffabsgrads, "md.cfdragcoeffabsgrad.weights_string");
263
264 for(j=0;j<num_cfdragcoeffabsgrads;j++){
265
266 int weight_vector_type=0;
267 if ((cfdragcoeffabsgrad_weights_M_s[j]==iomodel->numberofvertices) || (cfdragcoeffabsgrad_weights_M_s[j]==iomodel->numberofvertices+1)){
268 weight_vector_type=1;
269 }
270 else if ((cfdragcoeffabsgrad_weights_M_s[j]==iomodel->numberofelements) || (cfdragcoeffabsgrad_weights_M_s[j]==iomodel->numberofelements+1)){
271 weight_vector_type=2;
272 }
273 else
274 _error_("cfdragcoeffabsgrad weight size not supported yet");
275
276 /*First create a cfdragcoeffabsgrad object for that specific string (cfdragcoeffabsgrad_model_string_s[j]):*/
277 output_definitions->AddObject(new Cfdragcoeffabsgrad(cfdragcoeffabsgrad_name_s[j],StringToEnumx(cfdragcoeffabsgrad_definitionstring_s[j]),StringToEnumx(cfdragcoeffabsgrad_weights_string_s[j]),false));
278
279 /*Now, for this particular cfdragcoeffabsgrad object, make sure we plug into the elements: the observation, and the weights.*/
280 for(Object* & object : elements->objects){
281
282 Element* element=xDynamicCast<Element*>(object);
283
284 element->DatasetInputAdd(StringToEnumx(cfdragcoeffabsgrad_definitionstring_s[j]),cfdragcoeffabsgrad_weights_s[j],inputs,iomodel,cfdragcoeffabsgrad_weights_M_s[j],cfdragcoeffabsgrad_weights_N_s[j],weight_vector_type,StringToEnumx(cfdragcoeffabsgrad_weights_string_s[j]),7,WeightsSurfaceObservationEnum);
285
286 }
287
288 }
289
290 /*Free ressources:*/
291 for(j=0;j<num_cfdragcoeffabsgrads;j++){
292 char* string=NULL;
293 IssmDouble* matrix = NULL;
294
295 string = cfdragcoeffabsgrad_definitionstring_s[j]; xDelete<char>(string);
296 string = cfdragcoeffabsgrad_weights_string_s[j]; xDelete<char>(string);
297 string = cfdragcoeffabsgrad_name_s[j]; xDelete<char>(string);
298 matrix = cfdragcoeffabsgrad_weights_s[j]; xDelete<IssmDouble>(matrix);
299 }
300 xDelete<char*>(cfdragcoeffabsgrad_name_s);
301 xDelete<char*>(cfdragcoeffabsgrad_definitionstring_s);
302 xDelete<IssmDouble*>(cfdragcoeffabsgrad_weights_s);
303 xDelete<int>(cfdragcoeffabsgrad_weights_M_s);
304 xDelete<int>(cfdragcoeffabsgrad_weights_N_s);
305 xDelete<char*>(cfdragcoeffabsgrad_weights_string_s);
306 /*}}}*/
307 }
308 else if (output_definition_enums[i]==CfsurfacelogvelEnum){
309 /*Deal with cfsurfacelogvel: {{{*/
310
311 /*cfsurfacelogvel variables: */
312 int num_cfsurfacelogvels;
313 char **cfsurfacelogvel_name = NULL;
314 char **cfsurfacelogvel_definitionstring = NULL;
315 IssmDouble **cfsurfacelogvel_vxobs = NULL;
316 IssmDouble **cfsurfacelogvel_vyobs = NULL;
317 char **cfsurfacelogvel_vxobs_string = NULL;
318 char **cfsurfacelogvel_vyobs_string = NULL;
319 int *cfsurfacelogvel_observation_M = NULL;
320 int *cfsurfacelogvel_observation_N = NULL;
321 IssmDouble **cfsurfacelogvel_weights = NULL;
322 int *cfsurfacelogvel_weights_M = NULL;
323 int *cfsurfacelogvel_weights_N = NULL;
324 char **cfsurfacelogvel_weightstring = NULL;
325 IssmDouble *cfsurfacelogvel_datatime = NULL;
326
327 /*Fetch name, modeltring, observation, observationtring, etc ... (see src/m/classes/cfsurfacelogvel.m): */
328 iomodel->FetchMultipleData(&cfsurfacelogvel_name,&num_cfsurfacelogvels,"md.cfsurfacelogvel.name");
329 iomodel->FetchMultipleData(&cfsurfacelogvel_definitionstring,&num_cfsurfacelogvels,"md.cfsurfacelogvel.definitionstring");
330 iomodel->FetchMultipleData(&cfsurfacelogvel_vxobs,&cfsurfacelogvel_observation_M,&cfsurfacelogvel_observation_N,&num_cfsurfacelogvels,"md.cfsurfacelogvel.vxobs");
331 iomodel->FetchMultipleData(&cfsurfacelogvel_vxobs_string,&num_cfsurfacelogvels,"md.cfsurfacelogvel.vxobs_string");
332 iomodel->FetchMultipleData(&cfsurfacelogvel_vyobs,NULL,NULL,&num_cfsurfacelogvels,"md.cfsurfacelogvel.vyobs");
333 iomodel->FetchMultipleData(&cfsurfacelogvel_vyobs_string,&num_cfsurfacelogvels,"md.cfsurfacelogvel.vyobs_string");
334 iomodel->FetchMultipleData(&cfsurfacelogvel_weights,&cfsurfacelogvel_weights_M,&cfsurfacelogvel_weights_N,&num_cfsurfacelogvels,"md.cfsurfacelogvel.weights");
335 iomodel->FetchMultipleData(&cfsurfacelogvel_weightstring,&num_cfsurfacelogvels,"md.cfsurfacelogvel.weights_string");
336 iomodel->FetchMultipleData(&cfsurfacelogvel_datatime,&num_cfsurfacelogvels,"md.cfsurfacelogvel.datatime");
337
338 for(j=0;j<num_cfsurfacelogvels;j++){
339
340 int obs_vector_type=0;
341 if ((cfsurfacelogvel_observation_M[j]==iomodel->numberofvertices) || (cfsurfacelogvel_observation_M[j]==iomodel->numberofvertices+1)){
342 obs_vector_type=1;
343 }
344 else if ((cfsurfacelogvel_observation_M[j]==iomodel->numberofelements) || (cfsurfacelogvel_observation_M[j]==iomodel->numberofelements+1)){
345 obs_vector_type=2;
346 }
347 else
348 _error_("cfsurfacelogvel observation size not supported yet");
349
350 int weight_vector_type=0;
351 if ((cfsurfacelogvel_weights_M[j]==iomodel->numberofvertices) || (cfsurfacelogvel_weights_M[j]==iomodel->numberofvertices+1)){
352 weight_vector_type=1;
353 }
354 else if ((cfsurfacelogvel_weights_M[j]==iomodel->numberofelements) || (cfsurfacelogvel_weights_M[j]==iomodel->numberofelements+1)){
355 weight_vector_type=2;
356 }
357 else
358 _error_("cfsurfacelogvel weight size not supported yet");
359
360 /*First create a cfsurfacelogvel object for that specific string (cfsurfacelogvel_modeltring[j]):*/
361 output_definitions->AddObject(new Cfsurfacelogvel(cfsurfacelogvel_name[j],StringToEnumx(cfsurfacelogvel_definitionstring[j]),cfsurfacelogvel_datatime[j],false));
362
363 /*Now, for this particular cfsurfacelogvel object, make sure we plug into the elements: the observation, and the weights.*/
364 for(Object* & object : elements->objects){
365
366 Element* element=xDynamicCast<Element*>(object);
367
368 element->DatasetInputAdd(StringToEnumx(cfsurfacelogvel_definitionstring[j]),cfsurfacelogvel_vxobs[j],inputs,iomodel,cfsurfacelogvel_observation_M[j],cfsurfacelogvel_observation_N[j],obs_vector_type,StringToEnumx(cfsurfacelogvel_vxobs_string[j]),7,VxObsEnum);
369 element->DatasetInputAdd(StringToEnumx(cfsurfacelogvel_definitionstring[j]),cfsurfacelogvel_vyobs[j],inputs,iomodel,cfsurfacelogvel_observation_M[j],cfsurfacelogvel_observation_N[j],obs_vector_type,StringToEnumx(cfsurfacelogvel_vyobs_string[j]),7,VyObsEnum);
370 element->DatasetInputAdd(StringToEnumx(cfsurfacelogvel_definitionstring[j]),cfsurfacelogvel_weights[j],inputs,iomodel,cfsurfacelogvel_weights_M[j],cfsurfacelogvel_weights_N[j],weight_vector_type,StringToEnumx(cfsurfacelogvel_weightstring[j]),7,WeightsSurfaceObservationEnum);
371
372 }
373
374 }
375
376 /*Free ressources:*/
377 for(j=0;j<num_cfsurfacelogvels;j++){
378 char* string=NULL;
379 IssmDouble* matrix = NULL;
380
381 string = cfsurfacelogvel_definitionstring[j]; xDelete<char>(string);
382 string = cfsurfacelogvel_vxobs_string[j]; xDelete<char>(string);
383 string = cfsurfacelogvel_vyobs_string[j]; xDelete<char>(string);
384 string = cfsurfacelogvel_weightstring[j]; xDelete<char>(string);
385 string = cfsurfacelogvel_name[j]; xDelete<char>(string);
386 matrix = cfsurfacelogvel_weights[j]; xDelete<IssmDouble>(matrix);
387 matrix = cfsurfacelogvel_vxobs[j]; xDelete<IssmDouble>(matrix);
388 matrix = cfsurfacelogvel_vyobs[j]; xDelete<IssmDouble>(matrix);
389 }
390 xDelete<char*>(cfsurfacelogvel_name);
391 xDelete<char*>(cfsurfacelogvel_definitionstring);
392 xDelete<int>(cfsurfacelogvel_observation_M);
393 xDelete<IssmDouble*>(cfsurfacelogvel_vxobs);
394 xDelete<IssmDouble*>(cfsurfacelogvel_vyobs);
395 xDelete<char*>(cfsurfacelogvel_vxobs_string);
396 xDelete<char*>(cfsurfacelogvel_vyobs_string);
397 xDelete<int>(cfsurfacelogvel_observation_N);
398 xDelete<IssmDouble*>(cfsurfacelogvel_weights);
399 xDelete<int>(cfsurfacelogvel_weights_M);
400 xDelete<int>(cfsurfacelogvel_weights_N);
401 xDelete<char*>(cfsurfacelogvel_weightstring);
402 xDelete<IssmDouble>(cfsurfacelogvel_datatime);
403 /*}}}*/
404 }
405 else if (output_definition_enums[i]==CflevelsetmisfitEnum){
406 /*Deal with cflevelsetmisfit: {{{*/
407
408 /*cflevelsetmisfit variables: */
409 int num_cflevelsetmisfits;
410 char** cflevelsetmisfit_name_s = NULL;
411 char** cflevelsetmisfit_definitionstring_s = NULL;
412 char** cflevelsetmisfit_model_string_s = NULL;
413 IssmDouble** cflevelsetmisfit_observation_s = NULL;
414 char** cflevelsetmisfit_observation_string_s = NULL;
415 int* cflevelsetmisfit_observation_M_s = NULL;
416 int* cflevelsetmisfit_observation_N_s = NULL;
417 IssmDouble** cflevelsetmisfit_weights_s = NULL;
418 int* cflevelsetmisfit_weights_M_s = NULL;
419 int* cflevelsetmisfit_weights_N_s = NULL;
420 char** cflevelsetmisfit_weights_string_s = NULL;
421 IssmDouble* cflevelsetmisfit_datatime_s = NULL;
422
423 /*Fetch name, model_string, observation, observation_string, etc ... (see src/m/classes/cflevelsetmisfit.m): */
424 iomodel->FetchMultipleData(&cflevelsetmisfit_name_s,&num_cflevelsetmisfits, "md.cflevelsetmisfit.name");
425 iomodel->FetchMultipleData(&cflevelsetmisfit_definitionstring_s,&num_cflevelsetmisfits, "md.cflevelsetmisfit.definitionstring");
426 iomodel->FetchMultipleData(&cflevelsetmisfit_model_string_s,&num_cflevelsetmisfits, "md.cflevelsetmisfit.model_string");
427 iomodel->FetchMultipleData(&cflevelsetmisfit_observation_s,&cflevelsetmisfit_observation_M_s,&cflevelsetmisfit_observation_N_s,&num_cflevelsetmisfits, "md.cflevelsetmisfit.observation");
428 iomodel->FetchMultipleData(&cflevelsetmisfit_observation_string_s,&num_cflevelsetmisfits, "md.cflevelsetmisfit.observation_string");
429 iomodel->FetchMultipleData(&cflevelsetmisfit_weights_s,&cflevelsetmisfit_weights_M_s,&cflevelsetmisfit_weights_N_s,&num_cflevelsetmisfits, "md.cflevelsetmisfit.weights");
430 iomodel->FetchMultipleData(&cflevelsetmisfit_weights_string_s,&num_cflevelsetmisfits, "md.cflevelsetmisfit.weights_string");
431 iomodel->FetchMultipleData(&cflevelsetmisfit_datatime_s,&num_cflevelsetmisfits, "md.cflevelsetmisfit.datatime");
432
433 for(j=0;j<num_cflevelsetmisfits;j++){
434 int obs_vector_type=0;
435 if ((cflevelsetmisfit_observation_M_s[j]==iomodel->numberofvertices) || (cflevelsetmisfit_observation_M_s[j]==iomodel->numberofvertices+1)){
436 obs_vector_type=1;
437 }
438 else if ((cflevelsetmisfit_observation_M_s[j]==iomodel->numberofelements) || (cflevelsetmisfit_observation_M_s[j]==iomodel->numberofelements+1)){
439 obs_vector_type=2;
440 }
441 else
442 _error_("cflevelsetmisfit observation size not supported yet");
443
444 int weight_vector_type=0;
445 if ((cflevelsetmisfit_weights_M_s[j]==iomodel->numberofvertices) || (cflevelsetmisfit_weights_M_s[j]==iomodel->numberofvertices+1)){
446 weight_vector_type=1;
447 }
448 else if ((cflevelsetmisfit_weights_M_s[j]==iomodel->numberofelements) || (cflevelsetmisfit_weights_M_s[j]==iomodel->numberofelements+1)){
449 weight_vector_type=2;
450 }
451 else
452 _error_("cflevelsetmisfit weight size not supported yet");
453
454 /*First create a cflevelsetmisfit object for that specific string (cflevelsetmisfit_model_string_s[j]):*/
455 output_definitions->AddObject(new Cflevelsetmisfit(cflevelsetmisfit_name_s[j],StringToEnumx(cflevelsetmisfit_definitionstring_s[j]),StringToEnumx(cflevelsetmisfit_model_string_s[j]),StringToEnumx(cflevelsetmisfit_observation_string_s[j]),StringToEnumx(cflevelsetmisfit_weights_string_s[j]),cflevelsetmisfit_datatime_s[j],false));
456
457 /*Now, for this particular cflevelsetmisfit object, make sure we plug into the elements: the observation, and the weights.*/
458 for(Object* & object : elements->objects){
459 Element* element=xDynamicCast<Element*>(object);
460 element->DatasetInputAdd(StringToEnumx(cflevelsetmisfit_definitionstring_s[j]),cflevelsetmisfit_observation_s[j],inputs,iomodel,cflevelsetmisfit_observation_M_s[j],cflevelsetmisfit_observation_N_s[j],obs_vector_type,StringToEnumx(cflevelsetmisfit_observation_string_s[j]),7,LevelsetObservationEnum);
461 element->DatasetInputAdd(StringToEnumx(cflevelsetmisfit_definitionstring_s[j]),cflevelsetmisfit_weights_s[j],inputs,iomodel,cflevelsetmisfit_weights_M_s[j],cflevelsetmisfit_weights_N_s[j],weight_vector_type,StringToEnumx(cflevelsetmisfit_weights_string_s[j]),7,WeightsLevelsetObservationEnum);
462 }
463 }
464
465 /*Free ressources:*/
466 for(j=0;j<num_cflevelsetmisfits;j++){
467 char* string=NULL;
468 IssmDouble* matrix = NULL;
469
470 string = cflevelsetmisfit_definitionstring_s[j]; xDelete<char>(string);
471 string = cflevelsetmisfit_observation_string_s[j]; xDelete<char>(string);
472 string = cflevelsetmisfit_model_string_s[j]; xDelete<char>(string);
473 string = cflevelsetmisfit_weights_string_s[j]; xDelete<char>(string);
474 string = cflevelsetmisfit_name_s[j]; xDelete<char>(string);
475 matrix = cflevelsetmisfit_observation_s[j]; xDelete<IssmDouble>(matrix);
476 matrix = cflevelsetmisfit_weights_s[j]; xDelete<IssmDouble>(matrix);
477 }
478 xDelete<char*>(cflevelsetmisfit_name_s);
479 xDelete<char*>(cflevelsetmisfit_model_string_s);
480 xDelete<char*>(cflevelsetmisfit_definitionstring_s);
481 xDelete<IssmDouble*>(cflevelsetmisfit_observation_s);
482 xDelete<char*>(cflevelsetmisfit_observation_string_s);
483 xDelete<int>(cflevelsetmisfit_observation_M_s);
484 xDelete<int>(cflevelsetmisfit_observation_N_s);
485 xDelete<IssmDouble*>(cflevelsetmisfit_weights_s);
486 xDelete<int>(cflevelsetmisfit_weights_M_s);
487 xDelete<int>(cflevelsetmisfit_weights_N_s);
488 xDelete<char*>(cflevelsetmisfit_weights_string_s);
489 xDelete<IssmDouble>(cflevelsetmisfit_datatime_s);
490 /*}}}*/
491 }
492 else if (output_definition_enums[i]==NodalvalueEnum){
493 /*Deal with nodal values: {{{*/
494
495 /*nodal value variables: */
496 int numnodalvalues;
497 char** nodalvalue_name_s = NULL;
498 char** nodalvalue_definitionstrings = NULL;
499 char** nodalvalue_modelstrings = NULL;
500 int* nodalvalue_node_s = NULL;
501
502 /*Fetch name, model_enum, etc ... (see src/m/classes/nodalvalue.m): */
503 iomodel->FetchMultipleData(&nodalvalue_name_s,&numnodalvalues, "md.nodalvalue.name");
504 iomodel->FetchMultipleData(&nodalvalue_definitionstrings,&numnodalvalues, "md.nodalvalue.definitionenum");
505 iomodel->FetchMultipleData(&nodalvalue_modelstrings,&numnodalvalues, "md.nodalvalue.model_enum");
506 iomodel->FetchMultipleData(&nodalvalue_node_s,&numnodalvalues, "md.nodalvalue.node");
507
508 for(j=0;j<numnodalvalues;j++){
509
510 /*First create a nodalvalue object for that specific enum (nodalvalue_model_enum_s[j]):*/
511 output_definitions->AddObject(new Nodalvalue(nodalvalue_name_s[j],StringToEnumx(nodalvalue_definitionstrings[j]),StringToEnumx(nodalvalue_modelstrings[j]),nodalvalue_node_s[j]-1)); //-1 because matlab to c indexing.
512 }
513
514 /*Free ressources:*/
515 for(j=0;j<numnodalvalues;j++){
516 char* string=NULL;
517 string = nodalvalue_name_s[j]; xDelete<char>(string);
518 string = nodalvalue_definitionstrings[j]; xDelete<char>(string);
519 string = nodalvalue_modelstrings[j]; xDelete<char>(string);
520 }
521 xDelete<char*>(nodalvalue_name_s);
522 xDelete<char*>(nodalvalue_modelstrings);
523 xDelete<char*>(nodalvalue_definitionstrings);
524 xDelete<int>(nodalvalue_node_s);
525 /*}}}*/
526 }
527 else if (output_definition_enums[i]==MassconEnum){
528 /*Deal with masscons: {{{*/
529
530 /*masscon variables: */
531 int nummasscons;
532 char** masscon_name_s = NULL;
533 char** masscon_definitionstring_s = NULL;
534 IssmDouble** masscon_levelset_s = NULL;
535 int* masscon_levelset_M_s = NULL;
536 int* masscon_levelset_N_s = NULL;
537
538 /*Fetch name and levelset, etc ... (see src/m/classes/masscon.m): */
539 iomodel->FetchMultipleData(&masscon_name_s,&nummasscons, "md.masscon.name");
540 iomodel->FetchMultipleData(&masscon_definitionstring_s,&nummasscons, "md.masscon.definitionstring");
541 iomodel->FetchMultipleData(&masscon_levelset_s,&masscon_levelset_M_s,&masscon_levelset_N_s,&nummasscons,"md.masscon.levelset");
542
543 for(j=0;j<nummasscons;j++){
544
545 /*Create a masscon object: */
546 output_definitions->AddObject(new Masscon(masscon_name_s[j],StringToEnumx(masscon_definitionstring_s[j]),masscon_levelset_s[j],masscon_levelset_M_s[j]));
547
548 }
549
550 /*Free ressources:*/
551 for(j=0;j<nummasscons;j++){
552 char* string=NULL;
553 IssmDouble* matrix = NULL;
554
555 string = masscon_name_s[j]; xDelete<char>(string);
556 string = masscon_definitionstring_s[j]; xDelete<char>(string);
557 matrix = masscon_levelset_s[j]; xDelete<IssmDouble>(matrix);
558 }
559 xDelete<char*>(masscon_name_s);
560 xDelete<IssmDouble*>(masscon_levelset_s);
561 xDelete<int>(masscon_levelset_M_s);
562 xDelete<int>(masscon_levelset_N_s);
563 xDelete<char*>(masscon_definitionstring_s);
564
565 /*}}}*/
566 }
567 else if (output_definition_enums[i]==MassconaxpbyEnum){
568 /*Deal with masscon combinations: {{{*/
569
570 /*masscon variables: */
571 char** masscon_name_s = NULL;
572 char** masscon_definitionstring_s = NULL;
573 char** masscon_namex_s = NULL;
574 char** masscon_namey_s = NULL;
575 IssmDouble* masscon_alpha_s = NULL;
576 IssmDouble* masscon_beta_s = NULL;
577 int num;
578
579 /*Fetch names and multiplicators, etc ... (see src/m/classes/masscon_axpby.m): */
580 iomodel->FetchMultipleData(&masscon_name_s,&num, "md.massconaxpby.name");
581 iomodel->FetchMultipleData(&masscon_definitionstring_s,&num,"md.massconaxpby.definitionstring");
582 iomodel->FetchMultipleData(&masscon_namex_s,&num, "md.massconaxpby.namex");
583 iomodel->FetchMultipleData(&masscon_namey_s,&num, "md.massconaxpby.namey");
584 iomodel->FetchMultipleData(&masscon_alpha_s,&num, "md.massconaxpby.alpha");
585 iomodel->FetchMultipleData(&masscon_beta_s,&num, "md.massconaxpby.beta");
586 for(j=0;j<num;j++){
587
588 /*Create a masscon axpyb object: */
589 output_definitions->AddObject(new Massconaxpby(masscon_name_s[j],StringToEnumx(masscon_definitionstring_s[j]),masscon_namex_s[j],masscon_namey_s[j],masscon_alpha_s[j],masscon_beta_s[j]));
590
591 }
592
593 /*Free ressources:*/
594 for(j=0;j<num;j++){
595 char* string=NULL;
596 string = masscon_definitionstring_s[j]; xDelete<char>(string);
597 string = masscon_name_s[j]; xDelete<char>(string);
598 string = masscon_namex_s[j]; xDelete<char>(string);
599 string = masscon_namey_s[j]; xDelete<char>(string);
600 }
601 xDelete<char*>(masscon_definitionstring_s);
602 xDelete<char*>(masscon_name_s);
603 xDelete<char*>(masscon_namex_s);
604 xDelete<char*>(masscon_namey_s);
605 xDelete<IssmDouble>(masscon_alpha_s);
606 xDelete<IssmDouble>(masscon_beta_s);
607 /*}}}*/
608 }
609 else if (output_definition_enums[i]==RegionaloutputEnum){
610 /*Deal with regional output: {{{*/
611
612 /*regional output variables: */
613 int numout;
614 char** reg_name_s = NULL;
615 char** reg_definitionstring_s = NULL;
616 char** reg_outputnamestring_s = NULL;
617 IssmDouble** reg_mask_s = NULL;
618 int* reg_mask_M_s = NULL;
619 int* reg_mask_N_s = NULL;
620
621 /*Fetch name and mask, etc ... (see src/m/classes/regionaloutput.m): */
622 iomodel->FetchMultipleData(&reg_name_s,&numout, "md.regionaloutput.name");
623 iomodel->FetchMultipleData(&reg_definitionstring_s,&numout, "md.regionaloutput.definitionstring");
624 iomodel->FetchMultipleData(&reg_outputnamestring_s,&numout, "md.regionaloutput.outputnamestring");
625 iomodel->FetchMultipleData(&reg_mask_s,&reg_mask_M_s,&reg_mask_N_s,&numout, "md.regionaloutput.mask");
626 for(j=0;j<numout;j++){
627
628 /*Create a regional output object: */
629 output_definitions->AddObject(new Regionaloutput(reg_name_s[j],StringToEnumx(reg_definitionstring_s[j]),reg_outputnamestring_s[j],reg_mask_s[j],reg_mask_M_s[j]));
630
631 }
632
633 /*Free ressources:*/
634 for(j=0;j<numout;j++){
635 char* string=NULL;
636 IssmDouble* matrix = NULL;
637
638 string = reg_name_s[j]; xDelete<char>(string);
639 string = reg_definitionstring_s[j]; xDelete<char>(string);
640 string = reg_outputnamestring_s[j]; xDelete<char>(string);
641 matrix = reg_mask_s[j]; xDelete<IssmDouble>(matrix);
642 }
643 xDelete<char*>(reg_name_s);
644 xDelete<IssmDouble*>(reg_mask_s);
645 xDelete<int>(reg_mask_M_s);
646 xDelete<int>(reg_mask_N_s);
647 xDelete<char*>(reg_outputnamestring_s);
648 xDelete<char*>(reg_definitionstring_s);
649 /*}}}*/
650 }
651 else if (output_definition_enums[i]==NumberedcostfunctionEnum){
652 /*Deal with numbered cost function: {{{*/
653
654 /*Intermediary*/
655 int numout,numout2;
656 char **ncf_name_s = NULL;
657 char **ncf_definitionstring_s = NULL;
658 char **cost_functions = NULL;
659 IssmDouble **cost_functions_weights = NULL;
660 int* cost_functions_weights_M = NULL;
661 int* cost_functions_weights_N = NULL;
662 int cost_function,domaintype;
663 int num_cost_functions;
664
665 /*Process cost functions and convert from string to enums*/
666 iomodel->FindConstant(&num_cost_functions,"md.numberedcostfunction.num_cost_functions");
667 iomodel->FindConstant(&cost_functions,&num_cost_functions,"md.numberedcostfunction.cost_functions");
668 if(num_cost_functions<1) _error_("No cost functions found");
669 int* cost_function_enums=xNew<int>(num_cost_functions);
670 for(int i=0;i<num_cost_functions;++i){
671 cost_function_enums[i]=StringToEnumx(cost_functions[i]);
672 }
673
674 iomodel->FetchMultipleData(&ncf_name_s,&numout,"md.numberedcostfunction.name");
675 iomodel->FetchMultipleData(&ncf_definitionstring_s,&numout2,"md.numberedcostfunction.definitionstring"); _assert_(numout2 == numout);
676 iomodel->FetchMultipleData(&cost_functions_weights,&cost_functions_weights_M,&cost_functions_weights_N,&numout2,"md.numberedcostfunction.cost_functions_coefficients"); _assert_(numout2 == numout);
677 if(numout!=1) _error_("not implemented yet, check code here");
678
679 /*Fetch Observations */
680 iomodel->FindConstant(&domaintype,"md.mesh.domain_type");
681 for(int i=0;i<num_cost_functions;i++){
682 cost_function=cost_function_enums[i];
683 if( cost_function==ThicknessAbsMisfitEnum) iomodel->FetchDataToInput(inputs,elements,"md.numberedcostfunction.thickness_obs",InversionThicknessObsEnum);
684 else if(cost_function==SurfaceAbsMisfitEnum) iomodel->FetchDataToInput(inputs,elements,"md.numberedcostfunction.surface_obs",InversionSurfaceObsEnum);
685 else if(cost_function==SurfaceAbsVelMisfitEnum
686 || cost_function==SurfaceRelVelMisfitEnum
687 || cost_function==SurfaceLogVelMisfitEnum
688 || cost_function==SurfaceLogVxVyMisfitEnum
689 || cost_function==SurfaceAverageVelMisfitEnum){
690 iomodel->FetchDataToInput(inputs,elements,"md.numberedcostfunction.vx_obs",InversionVxObsEnum);
691 if(domaintype!=Domain2DverticalEnum) iomodel->FetchDataToInput(inputs,elements,"md.numberedcostfunction.vy_obs",InversionVyObsEnum);
692 }
693 }
694
695 for(j=0;j<numout;j++){
696
697 /*Now, for this particular misfit object, make sure we plug into the elements: the observation, and the weights.*/
698 for(Object* & object : elements->objects){
699 Element* element=xDynamicCast<Element*>(object);
700 element->DatasetInputCreate(cost_functions_weights[j],cost_functions_weights_M[j],cost_functions_weights_N[j],cost_function_enums,num_cost_functions,inputs,iomodel,InversionCostFunctionsCoefficientsEnum);
701 }
702 output_definitions->AddObject(new Numberedcostfunction(ncf_name_s[j],StringToEnumx(ncf_definitionstring_s[j]),num_cost_functions,cost_function_enums));
703 }
704
705 /*Free data: */
706 iomodel->DeleteData(2,"md.numberedcostfunction.name","md.numberedcostfunction.definitionstring");
707 xDelete<int>(cost_function_enums);
708 for(int i=0;i<num_cost_functions;i++) xDelete<char>(cost_functions[i]);
709 xDelete<char*>(cost_functions);
710
711 /*Free ressources:*/
712 for(j=0;j<numout;j++){
713 xDelete<char>(ncf_name_s[j]);
714 xDelete<char>(ncf_definitionstring_s[j]);
715 xDelete<IssmDouble>(cost_functions_weights[j]);
716 }
717 xDelete<char*>(ncf_name_s);
718 xDelete<char*>(ncf_definitionstring_s);
719 xDelete<int>(cost_functions_weights_M);
720 xDelete<int>(cost_functions_weights_N);
721 xDelete<IssmDouble*>(cost_functions_weights);
722
723 /*}}}*/
724 }
725 else if (output_definition_enums[i]==RadarEnum){
726 /*Deal with radar: {{{*/
727 int numout;
728 char **radar_name_s = NULL;
729 char **radar_definitionstring_s = NULL;
730 int **radar_ice_period_s = NULL;
731
732 /*Fetch name and definition, etc ... (see src/m/classes/radar.m): */
733 iomodel->FetchMultipleData(&radar_definitionstring_s,&numout,"md.radar.definitionstring");
734 iomodel->FetchMultipleData(&radar_name_s,&numout,"md.radar.name");
735 if(numout>1) _error_("not suppored yet");
736 /*Fetch necessary inputs for calculation*/
737 //iomodel->FetchDataToInput(elements,"md.ice_period",RadarIcePeriodEnum);
738
739 /*Add to output definitions*/
740 output_definitions->AddObject(new Radar(radar_name_s[0],StringToEnumx(radar_definitionstring_s[0])));
741 /*}}}*/
742 }
743 else _error_("output definition enum " << EnumToStringx(output_definition_enums[i]) << " not supported yet!");
744 }
745 }
746 parameters->AddObject(new DataSetParam(OutputdefinitionEnum,output_definitions));
747
748 /*Free ressources:*/
749 delete output_definitions;
750 xDelete<int>(output_definition_enums);
751
752}
Note: See TracBrowser for help on using the repository browser.