Context Navigation

← Previous Revision
Next Revision →
Normal
Revision Log

CreateOutputDefinitions.cpp

Last change on this file was 27220, checked in by Eric.Larour, 3 years ago
CHG: fixing simple leaks.
File size: 40.3 KB

Rev	Line
[16388]	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
[25379]	10	void CreateOutputDefinitions(Elements* elements,Parameters* parameters,Inputs* inputs,IoModel* iomodel){
[16388]	11
	12	int i,j;
[23066]	13
[16787]	14	DataSet* output_definitions = NULL;
	15	int* output_definition_enums = NULL;
[16474]	16	int num_output_definitions;
[16388]	17
	18	/Create output_definitions dataset: /
	19	output_definitions=new DataSet();
[21049]	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	}
[24205]	28	// free data:
[21049]	29	for(int i=0;i<num_output_definitions;i++) xDelete<char>(out_strings[i]);
	30	xDelete<char*>(out_strings);
	31
[16388]	32	if(num_output_definitions){
	33	for (i=0;i<num_output_definitions;i++){
	34	if (output_definition_enums[i]==MassfluxatgateEnum){
[20690]	35	/Deal with mass flux gates:{{{ /
[16787]	36
	37	/massfluxatgate variables: /
[18941]	38	int temp,numgates;
[20690]	39	char **gatenames = NULL;
[21049]	40	char **gatedefinitionstrings = NULL;
[20690]	41	IssmDouble **gatesegments = NULL;
	42	int *gatesegments_M = NULL;
[16388]	43
	44	/Fetch segments and names: /
[20690]	45	iomodel->FetchMultipleData(&gatenames,&numgates, "md.massfluxatgate.name");
[21049]	46	iomodel->FetchMultipleData(&gatedefinitionstrings,&temp, "md.massfluxatgate.definitionstring"); _assert_(temp==numgates);
[21789]	47	iomodel->FetchMultipleData(&gatesegments,&gatesegments_M,NULL,&temp, "md.massfluxatgate.segments"); _assert_(temp==numgates);
[16388]	48
	49	for(j=0;j<numgates;j++){
[21049]	50	output_definitions->AddObject(new Massfluxatgate<IssmDouble>(gatenames[j],StringToEnumx(gatedefinitionstrings[j]),gatesegments_M[j],gatesegments[j]));
[16388]	51	}
	52	/Free ressources:/
	53	for(j=0;j<numgates;j++){
[21789]	54	char* string = gatenames[j]; xDelete<char>(string);
	55	char* string2 = gatedefinitionstrings[j]; xDelete<char>(string2);
	56	IssmDouble* gate = gatesegments[j]; xDelete<IssmDouble>(gate);
[16388]	57	}
	58	xDelete<char*>(gatenames);
	59	xDelete<IssmDouble*>(gatesegments);
	60	xDelete<int>(gatesegments_M);
[21049]	61	xDelete<char*>(gatedefinitionstrings);
[16388]	62	/}}}/
	63	}
[16787]	64	else if (output_definition_enums[i]==MisfitEnum){
	65	/Deal with misfits: {{{/
[23066]	66
[16787]	67	/misfit variables: /
	68	int nummisfits;
[21049]	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;
[16787]	82
[21049]	83	/Fetch name, model_string, observation, observation_string, etc ... (see src/m/classes/misfit.m): /
[20690]	84	iomodel->FetchMultipleData(&misfit_name_s,&nummisfits, "md.misfit.name");
[21049]	85	iomodel->FetchMultipleData(&misfit_definitionstring_s,&nummisfits, "md.misfit.definitionstring");
	86	iomodel->FetchMultipleData(&misfit_model_string_s,&nummisfits, "md.misfit.model_string");
[20690]	87	iomodel->FetchMultipleData(&misfit_observation_s,&misfit_observation_M_s,&misfit_observation_N_s,&nummisfits, "md.misfit.observation");
[21049]	88	iomodel->FetchMultipleData(&misfit_observation_string_s,&nummisfits, "md.misfit.observation_string");
[20690]	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");
[21049]	92	iomodel->FetchMultipleData(&misfit_weights_string_s,&nummisfits, "md.misfit.weights_string");
[16787]	93
	94	for(j=0;j<nummisfits;j++){
	95
[21744]	96	int obs_vector_type=0;
[22385]	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
[21744]	106	int weight_vector_type=0;
[22385]	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");
[21744]	115
[21049]	116	/First create a misfit object for that specific string (misfit_model_string_s[j]):/
[21738]	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])));
[16787]	118
	119	/Now, for this particular misfit object, make sure we plug into the elements: the observation, and the weights./
[25539]	120	for(Object* & object : elements->objects){
	121	Element* element=xDynamicCast<Element*>(object);
[25379]	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);
[16787]	124	}
	125
	126	}
	127
	128	/Free ressources:/
	129	for(j=0;j<nummisfits;j++){
	130	char* string=NULL;
	131	IssmDouble* matrix = NULL;
[21049]	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);
[16787]	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);
[21049]	142	xDelete<char*>(misfit_model_string_s);
	143	xDelete<char*>(misfit_definitionstring_s);
[16787]	144	xDelete<IssmDouble*>(misfit_observation_s);
[21049]	145	xDelete<char*>(misfit_observation_string_s);
[16787]	146	xDelete<int>(misfit_observation_M_s);
	147	xDelete<int>(misfit_observation_N_s);
[19098]	148	xDelete<int>(misfit_local_s);
[16787]	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);
[21049]	153	xDelete<char*>(misfit_weights_string_s);
[16787]	154	/}}}/
	155	}
[22507]	156	else if (output_definition_enums[i]==CfsurfacesquareEnum){
	157	/Deal with cfsurfacesquare: {{{/
[23066]	158
[22507]	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;
[26252]	172	IssmDouble* cfsurfacesquare_datatime_s = NULL;
[22507]	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./
[25539]	210	for(Object* & object : elements->objects){
	211	Element* element=xDynamicCast<Element*>(object);
[25379]	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);
[23066]	214
[22507]	215	}
	216
	217	}
	218
[24205]	219	/Free ressources:/
[22507]	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);
[26252]	243	xDelete<IssmDouble>(cfsurfacesquare_datatime_s);
[22507]	244	/}}}/
	245	}
[22612]	246	else if (output_definition_enums[i]==CfdragcoeffabsgradEnum){
	247	/Deal with cfdragcoeffabsgrad: {{{/
[23066]	248
[22612]	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]):/
[22971]	277	output_definitions->AddObject(new Cfdragcoeffabsgrad(cfdragcoeffabsgrad_name_s[j],StringToEnumx(cfdragcoeffabsgrad_definitionstring_s[j]),StringToEnumx(cfdragcoeffabsgrad_weights_string_s[j]),false));
[22612]	278
	279	/Now, for this particular cfdragcoeffabsgrad object, make sure we plug into the elements: the observation, and the weights./
[25539]	280	for(Object* & object : elements->objects){
[22612]	281
[25539]	282	Element* element=xDynamicCast<Element*>(object);
[23066]	283
[25379]	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);
[22612]	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	}
[22507]	308	else if (output_definition_enums[i]==CfsurfacelogvelEnum){
	309	/Deal with cfsurfacelogvel: {{{/
[23066]	310
[22507]	311	/cfsurfacelogvel variables: /
	312	int num_cfsurfacelogvels;
[26889]	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;
[22507]	326
[26889]	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");
[22507]	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./
[25539]	364	for(Object* & object : elements->objects){
[22507]	365
[25539]	366	Element* element=xDynamicCast<Element*>(object);
[23066]	367
[25379]	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);
[22507]	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);
[26252]	402	xDelete<IssmDouble>(cfsurfacelogvel_datatime);
[22507]	403	/}}}/
	404	}
[26252]	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	}
[20038]	492	else if (output_definition_enums[i]==NodalvalueEnum){
	493	/Deal with nodal values: {{{/
[23066]	494
[20038]	495	/nodal value variables: /
	496	int numnodalvalues;
	497	char** nodalvalue_name_s = NULL;
[21445]	498	char** nodalvalue_definitionstrings = NULL;
	499	char** nodalvalue_modelstrings = NULL;
[20038]	500	int* nodalvalue_node_s = NULL;
	501
	502	/Fetch name, model_enum, etc ... (see src/m/classes/nodalvalue.m): /
[20690]	503	iomodel->FetchMultipleData(&nodalvalue_name_s,&numnodalvalues, "md.nodalvalue.name");
[21445]	504	iomodel->FetchMultipleData(&nodalvalue_definitionstrings,&numnodalvalues, "md.nodalvalue.definitionenum");
	505	iomodel->FetchMultipleData(&nodalvalue_modelstrings,&numnodalvalues, "md.nodalvalue.model_enum");
[20690]	506	iomodel->FetchMultipleData(&nodalvalue_node_s,&numnodalvalues, "md.nodalvalue.node");
[20038]	507
	508	for(j=0;j<numnodalvalues;j++){
	509
	510	/First create a nodalvalue object for that specific enum (nodalvalue_model_enum_s[j]):/
[21445]	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.
[20038]	512	}
[23066]	513
[20038]	514	/Free ressources:/
	515	for(j=0;j<numnodalvalues;j++){
	516	char* string=NULL;
	517	string = nodalvalue_name_s[j]; xDelete<char>(string);
[27220]	518	string = nodalvalue_definitionstrings[j]; xDelete<char>(string);
	519	string = nodalvalue_modelstrings[j]; xDelete<char>(string);
[20038]	520	}
	521	xDelete<char*>(nodalvalue_name_s);
[21445]	522	xDelete<char*>(nodalvalue_modelstrings);
	523	xDelete<char*>(nodalvalue_definitionstrings);
[20038]	524	xDelete<int>(nodalvalue_node_s);
	525	/}}}/
	526	}
[18786]	527	else if (output_definition_enums[i]==MassconEnum){
	528	/Deal with masscons: {{{/
[21049]	529
[18786]	530	/masscon variables: /
	531	int nummasscons;
[21808]	532	char** masscon_name_s = NULL;
	533	char** masscon_definitionstring_s = NULL;
[18786]	534	IssmDouble** masscon_levelset_s = NULL;
[21808]	535	int* masscon_levelset_M_s = NULL;
	536	int* masscon_levelset_N_s = NULL;
[16787]	537
[18786]	538	/Fetch name and levelset, etc ... (see src/m/classes/masscon.m): /
[20690]	539	iomodel->FetchMultipleData(&masscon_name_s,&nummasscons, "md.masscon.name");
[21808]	540	iomodel->FetchMultipleData(&masscon_definitionstring_s,&nummasscons, "md.masscon.definitionstring");
[20690]	541	iomodel->FetchMultipleData(&masscon_levelset_s,&masscon_levelset_M_s,&masscon_levelset_N_s,&nummasscons,"md.masscon.levelset");
[21808]	542
[18786]	543	for(j=0;j<nummasscons;j++){
	544
	545	/Create a masscon object: /
[21808]	546	output_definitions->AddObject(new Masscon(masscon_name_s[j],StringToEnumx(masscon_definitionstring_s[j]),masscon_levelset_s[j],masscon_levelset_M_s[j]));
[18786]	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);
[21808]	556	string = masscon_definitionstring_s[j]; xDelete<char>(string);
[18786]	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);
[21808]	563	xDelete<char*>(masscon_definitionstring_s);
	564
[18786]	565	/}}}/
	566	}
[18812]	567	else if (output_definition_enums[i]==MassconaxpbyEnum){
	568	/Deal with masscon combinations: {{{/
[23066]	569
[18812]	570	/masscon variables: /
	571	char** masscon_name_s = NULL;
[21744]	572	char** masscon_definitionstring_s = NULL;
[18812]	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): /
[20690]	580	iomodel->FetchMultipleData(&masscon_name_s,&num, "md.massconaxpby.name");
[21744]	581	iomodel->FetchMultipleData(&masscon_definitionstring_s,&num,"md.massconaxpby.definitionstring");
[20690]	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");
[18812]	586	for(j=0;j<num;j++){
	587
	588	/Create a masscon axpyb object: /
[21744]	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]));
[18812]	590
	591	}
	592
	593	/Free ressources:/
	594	for(j=0;j<num;j++){
	595	char* string=NULL;
[21744]	596	string = masscon_definitionstring_s[j]; xDelete<char>(string);
[18812]	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	}
[21744]	601	xDelete<char*>(masscon_definitionstring_s);
[18812]	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	}
[21808]	609	else if (output_definition_enums[i]==RegionaloutputEnum){
	610	/Deal with regional output: {{{/
	611
[22409]	612	/regional output variables: /
[21808]	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
[22409]	628	/Create a regional output object: /
[21808]	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);
[22409]	649	/}}}/
[21808]	650	}
[22409]	651	else if (output_definition_enums[i]==NumberedcostfunctionEnum){
	652	/Deal with numbered cost function: {{{/
	653
	654	/Intermediary/
[22515]	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;
[22409]	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");
[22515]	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");
[22409]	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];
[25379]	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);
[22409]	685	else if(cost_function==SurfaceAbsVelMisfitEnum
	686	\|\| cost_function==SurfaceRelVelMisfitEnum
	687	\|\| cost_function==SurfaceLogVelMisfitEnum
	688	\|\| cost_function==SurfaceLogVxVyMisfitEnum
	689	\|\| cost_function==SurfaceAverageVelMisfitEnum){
[25379]	690	iomodel->FetchDataToInput(inputs,elements,"md.numberedcostfunction.vx_obs",InversionVxObsEnum);
	691	if(domaintype!=Domain2DverticalEnum) iomodel->FetchDataToInput(inputs,elements,"md.numberedcostfunction.vy_obs",InversionVyObsEnum);
[22409]	692	}
	693	}
	694
	695	for(j=0;j<numout;j++){
	696
[22515]	697	/Now, for this particular misfit object, make sure we plug into the elements: the observation, and the weights./
[25539]	698	for(Object* & object : elements->objects){
	699	Element* element=xDynamicCast<Element*>(object);
[25379]	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);
[22515]	701	}
[22410]	702	output_definitions->AddObject(new Numberedcostfunction(ncf_name_s[j],StringToEnumx(ncf_definitionstring_s[j]),num_cost_functions,cost_function_enums));
[22409]	703	}
[23066]	704
[22409]	705	/Free data: /
[22410]	706	iomodel->DeleteData(2,"md.numberedcostfunction.name","md.numberedcostfunction.definitionstring");
[22409]	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);
[22410]	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]);
[22515]	715	xDelete<IssmDouble>(cost_functions_weights[j]);
[22410]	716	}
	717	xDelete<char*>(ncf_name_s);
	718	xDelete<char*>(ncf_definitionstring_s);
[22515]	719	xDelete<int>(cost_functions_weights_M);
	720	xDelete<int>(cost_functions_weights_N);
	721	xDelete<IssmDouble*>(cost_functions_weights);
[26468]	722
[24205]	723	/}}}/
[22409]	724	}
[24205]	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	}
[22409]	743	else _error_("output definition enum " << EnumToStringx(output_definition_enums[i]) << " not supported yet!");
[24205]	744	}
[16388]	745	}
	746	parameters->AddObject(new DataSetParam(OutputdefinitionEnum,output_definitions));
	747
	748	/Free ressources:/
	749	delete output_definitions;
	750	xDelete<int>(output_definition_enums);
[22409]	751
[16388]	752	}

Note: See TracBrowser for help on using the repository browser.

Context Navigation

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

Download in other formats: