Ice Sheet System Model  4.18
Code documentation
Functions
CreateParametersDakota.cpp File Reference

general driver for creating parameters dataset More...

#include "../../../toolkits/toolkits.h"
#include "../../../classes/classes.h"
#include "../../../shared/shared.h"
#include "../../MeshPartitionx/MeshPartitionx.h"
#include "../ModelProcessorx.h"

Go to the source code of this file.

Functions

void CreateParametersDakota (Parameters *parameters, IoModel *iomodel, char *rootpath)
 

Detailed Description

general driver for creating parameters dataset

Definition in file CreateParametersDakota.cpp.

Function Documentation

◆ CreateParametersDakota()

void CreateParametersDakota ( Parameters *  parameters,
IoModel *  iomodel,
char *  rootpath 
)

Definition at line 11 of file CreateParametersDakota.cpp.

11  {
12 
13  /*variable declarations*/
14  int i;
15  char **responsedescriptors = NULL;
16  int numresponsedescriptors;
17  char **variabledescriptors = NULL;
18  int numvariabledescriptors;
19  char *descriptor = NULL;
20  double *dakota_parameter = NULL;
21 
22  //qmu files
23  char *qmuinname = NULL;
24  char *qmuerrname = NULL;
25  char *qmuoutname = NULL;
26 
27  //descriptors:
28  char tag[50];
29 
30  bool dakota_analysis = false;
31  char *name = NULL;
32  int numberofresponses;
33  int nrows,ncols;
34 
35  //variable partitions:
36  IssmDouble **array = NULL;
37  int *mdims_array = NULL;
38  int *ndims_array = NULL;
39  int num_partitions;
40  int* intarray = NULL;
41  int M,N;
42 
43  /*recover parameters: */
44  iomodel->FindConstant(&dakota_analysis,"md.qmu.isdakota");
45 
46  if(dakota_analysis){
47 
48  parameters->AddObject(iomodel->CopyConstantObject("md.qmu.output",QmuOutputEnum));
49 
50  iomodel->FindConstant(&name,"md.miscellaneous.name");
51  iomodel->FindConstant(&numberofresponses,"md.qmu.numberofresponses");
52 
53  /*name of qmu input, error and output files*/
54  qmuinname=xNew<char>((strlen(rootpath)+strlen(name)+strlen(".qmu.in")+1));
55  sprintf(qmuinname,"%s%s%s",rootpath,name,".qmu.in");
56  parameters->AddObject(new StringParam(QmuInNameEnum,qmuinname));
57 
58  qmuoutname=xNew<char>((strlen(rootpath)+strlen(name)+strlen(".qmu.out")+1));
59  sprintf(qmuoutname,"%s%s%s",rootpath,name,".qmu.out");
60  parameters->AddObject(new StringParam(QmuOutNameEnum,qmuoutname));
61 
62  qmuerrname=xNew<char>((strlen(rootpath)+strlen(name)+strlen(".qmu.err")+1));
63  sprintf(qmuerrname,"%s%s%s",rootpath,name,".qmu.err");
64  parameters->AddObject(new StringParam(QmuErrNameEnum,qmuerrname));
65 
66  /*Fetch variable descriptors*/
67  iomodel->FindConstant(&variabledescriptors,&numvariabledescriptors,"md.qmu.variabledescriptors");
68 
69  /*Fetch response descriptors*/
70  iomodel->FindConstant(&responsedescriptors,&numresponsedescriptors,"md.qmu.responsedescriptors");
71 
72  /*Ok, we have all the response descriptors. Build a parameter with it: */
73  parameters->AddObject(new StringArrayParam(QmuResponsedescriptorsEnum,responsedescriptors,numresponsedescriptors));
74 
75  /*Load partitioning vectors specific to variables:*/
76  iomodel->FetchData(&array,&mdims_array,&ndims_array,&num_partitions,"md.qmu.variablepartitions");
77  parameters->AddObject(new DoubleMatArrayParam(QmuVariablePartitionsEnum,array,num_partitions,mdims_array,ndims_array));
78  iomodel->FetchData(&intarray,&M,&N,"md.qmu.variablepartitions_npart");
79  parameters->AddObject(new IntMatParam(QmuVariablePartitionsNpartEnum,intarray,M,N));
80  xDelete<int>(intarray); iomodel->FetchData(&intarray,&M,&N,"md.qmu.variablepartitions_nt");
81  parameters->AddObject(new IntMatParam(QmuVariablePartitionsNtEnum,intarray,M,N));
82 
83  /*free arrays: {{{*/
84  for(i=0;i<num_partitions;i++){
85  IssmDouble* matrix=array[i];
86  xDelete<IssmDouble>(matrix);
87  }
88  xDelete<int>(mdims_array);
89  xDelete<int>(ndims_array);
90  xDelete<IssmDouble*>(array);
91  xDelete<int>(intarray);
92  /*}}}*/
93 
94  /*Load partitioning vectors specific to responses:*/
95  iomodel->FetchData(&array,&mdims_array,&ndims_array,&num_partitions,"md.qmu.responsepartitions");
96  parameters->AddObject(new DoubleMatArrayParam(QmuResponsePartitionsEnum,array,num_partitions,mdims_array,ndims_array));
97  iomodel->FetchData(&intarray,&M,&N,"md.qmu.responsepartitions_npart");
98  parameters->AddObject(new IntMatParam(QmuResponsePartitionsNpartEnum,intarray,M,N));
99 
100  /*free arrays: {{{*/
101  for(i=0;i<num_partitions;i++){
102  IssmDouble* matrix=array[i];
103  xDelete<IssmDouble>(matrix);
104  }
105  xDelete<int>(mdims_array);
106  xDelete<int>(ndims_array);
107  xDelete<IssmDouble*>(array);
108  xDelete<int>(intarray);
109  /*}}}*/
110 
111 
112  /*Deal with data needed because of qmu variables*/
113  DataSet* dataset_variable_descriptors = new DataSet(QmuVariableDescriptorsEnum);
114  for(i=0;i<numvariabledescriptors;i++){
115  if (strncmp(variabledescriptors[i],"scaled_",7)==0){
116  /*Ok, we are dealing with a variable that is distributed over nodes. Recover the name of the variable (ex: scaled_Thickness): */
117  sscanf(variabledescriptors[i],"scaled_%s",tag);
118 
119  /*Get field name and input enum from tag*/
120  char* fieldname = NULL;
121  int param_enum = -1;
122  FieldAndEnumFromCode(&param_enum,&fieldname,tag);
123 
124  /*Recover data: */
125  iomodel->FetchData(&dakota_parameter,&nrows,&ncols,fieldname);
126  if(nrows==iomodel->numberofvertices){
127  dataset_variable_descriptors->AddObject(new DoubleMatParam(param_enum,dakota_parameter,nrows,ncols));
128  }
129  else{
130  dataset_variable_descriptors->AddObject(new DoubleTransientMatParam(param_enum,dakota_parameter,nrows,ncols));
131  }
132  xDelete<double>(dakota_parameter);
133  xDelete<char>(fieldname);
134  }
135  }
136  parameters->AddObject(new DataSetParam(QmuVariableDescriptorsEnum,dataset_variable_descriptors));
137  delete dataset_variable_descriptors;
138 
139  /*clean-up*/
140  for(i=0;i<numresponsedescriptors;i++){
141  descriptor=responsedescriptors[i];
142  xDelete<char>(descriptor);
143  }
144  xDelete<char*>(responsedescriptors);
145  for(i=0;i<numvariabledescriptors;i++){
146  descriptor=variabledescriptors[i];
147  xDelete<char>(descriptor);
148  }
149  xDelete<char*>(variabledescriptors);
150  xDelete<char>(qmuinname);
151  xDelete<char>(qmuerrname);
152  xDelete<char>(qmuoutname);
153 
154 
155 
156  }
157 
158  /*Free data*/
159  xDelete<char>(name);
160 }
QmuResponsePartitionsNpartEnum
@ QmuResponsePartitionsNpartEnum
Definition: EnumDefinitions.h:298
QmuErrNameEnum
@ QmuErrNameEnum
Definition: EnumDefinitions.h:286
IssmDouble
double IssmDouble
Definition: types.h:37
QmuVariablePartitionsNtEnum
@ QmuVariablePartitionsNtEnum
Definition: EnumDefinitions.h:296
QmuOutNameEnum
@ QmuOutNameEnum
Definition: EnumDefinitions.h:289
DataSet::AddObject
int AddObject(Object *object)
Definition: DataSet.cpp:252
QmuVariableDescriptorsEnum
@ QmuVariableDescriptorsEnum
Definition: EnumDefinitions.h:293
QmuOutputEnum
@ QmuOutputEnum
Definition: EnumDefinitions.h:290
QmuResponsePartitionsEnum
@ QmuResponsePartitionsEnum
Definition: EnumDefinitions.h:297
Parameters::AddObject
void AddObject(Param *newparam)
Definition: Parameters.cpp:67
FieldAndEnumFromCode
void FieldAndEnumFromCode(int *out_enum, char **pfield, const char *string_in)
Definition: IoCodeConversions.cpp:9
QmuInNameEnum
@ QmuInNameEnum
Definition: EnumDefinitions.h:287
IoModel::numberofvertices
int numberofvertices
Definition: IoModel.h:99
IntMatParam
Definition: IntMatParam.h:20
IoModel::CopyConstantObject
Param * CopyConstantObject(const char *constant_name, int param_enum)
Definition: IoModel.cpp:418
QmuResponsedescriptorsEnum
@ QmuResponsedescriptorsEnum
Definition: EnumDefinitions.h:292
IoModel::FindConstant
void FindConstant(bool *pvalue, const char *constant_name)
Definition: IoModel.cpp:2362
StringArrayParam
Definition: StringArrayParam.h:20
IoModel::FetchData
void FetchData(bool *pboolean, const char *data_name)
Definition: IoModel.cpp:933
QmuVariablePartitionsNpartEnum
@ QmuVariablePartitionsNpartEnum
Definition: EnumDefinitions.h:295
DataSetParam
Definition: DataSetParam.h:20
StringParam
Definition: StringParam.h:20
DoubleMatParam
Definition: DoubleMatParam.h:20
DataSet
Declaration of DataSet class.
Definition: DataSet.h:14
DoubleTransientMatParam
Definition: DoubleTransientMatParam.h:20
DoubleMatArrayParam
Definition: DoubleMatArrayParam.h:20
QmuVariablePartitionsEnum
@ QmuVariablePartitionsEnum
Definition: EnumDefinitions.h:294
Generated on Thu Jul 2 2020 08:09:24 for Ice Sheet System Model by   doxygen 1.8.19