Ice Sheet System Model  4.18
Code documentation
Public Member Functions | Private Attributes
GenericExternalResult< ResultType > Class Template Reference

#include <GenericExternalResult.h>

Inheritance diagram for GenericExternalResult< ResultType >:
ExternalResult Object

Public Member Functions

void GenericEcho (void)
 
void GenericWriteData (FILE *fid)
 
void GenericMarshall (char **pmarshalled_data, int *pmarshalled_data_size, int marshall_direction)
 
 GenericExternalResult ()
 
 GenericExternalResult (int in_id, int in_enum_type, ResultType in_values, int in_M, int in_N, int in_step, IssmDouble in_time)
 
 GenericExternalResult (int in_id, const char *name_in, ResultType in_values, int in_M, int in_N, int in_step, IssmDouble in_time)
 
 GenericExternalResult (int in_id, int in_enum_type, ResultType in_value, int in_step, IssmDouble in_time)
 
 GenericExternalResult (int in_id, int in_enum_type, ResultType in_value)
 
 GenericExternalResult (int in_id, const char *in_result_name, ResultType in_value, int in_step, IssmDouble in_time)
 
 ~GenericExternalResult ()
 
Object * copy (void)
 
void Echo (void)
 
void DeepEcho (void)
 
int Id (void)
 
int ObjectEnum (void)
 
void Marshall (char **pmarshalled_data, int *pmarshalled_data_size, int marshall_direction)
 
void WriteData (FILE *fid, bool io_gather)
 
void Transpose (void)
 
char * GetResultName (void)
 
int GetResultEnum (void)
 
int GetStep (void)
 
double GetValue (void)
 
double * GetValues (void)
 
void DeepEcho (void)
 
int ObjectEnum (void)
 
void Marshall (char **pmarshalled_data, int *pmarshalled_data_size, int marshall_direction)
 
void DeepEcho (void)
 
int ObjectEnum (void)
 
void Marshall (char **pmarshalled_data, int *pmarshalled_data_size, int marshall_direction)
 
void DeepEcho (void)
 
int ObjectEnum (void)
 
double GetValue (void)
 
void Marshall (char **pmarshalled_data, int *pmarshalled_data_size, int marshall_direction)
 
 GenericExternalResult (int in_id, int in_enum_type, char *in_value, int in_step, IssmDouble in_time)
 
 GenericExternalResult (int in_id, int in_enum_type, char *in_value)
 
 ~GenericExternalResult ()
 
void DeepEcho (void)
 
void WriteData (FILE *fid, bool io_gather)
 
int ObjectEnum (void)
 
void Marshall (char **pmarshalled_data, int *pmarshalled_data_size, int marshall_direction)
 
 GenericExternalResult (int in_id, int in_enum_type, int *in_values, int in_M, int in_N, int in_step, IssmDouble in_time)
 
 GenericExternalResult (int in_id, const char *in_result_name, int *in_values, int in_M, int in_N, int in_step, IssmDouble in_time)
 
 GenericExternalResult (int in_id, int in_enum_type, int *in_value, int in_step, IssmDouble in_time)
 
 ~GenericExternalResult ()
 
void Echo (void)
 
void DeepEcho (void)
 
Object * copy (void)
 
void WriteData (FILE *fid, bool io_gather)
 
int ObjectEnum (void)
 
void Marshall (char **pmarshalled_data, int *pmarshalled_data_size, int marshall_direction)
 
 GenericExternalResult (int in_id, int in_enum_type, IssmPDouble *in_values, int in_M, int in_N, int in_step, IssmDouble in_time)
 
 GenericExternalResult (int in_id, const char *in_result_name, IssmPDouble *in_values, int in_M, int in_N, int in_step, IssmDouble in_time)
 
 GenericExternalResult (int in_id, int in_enum_type, IssmPDouble *in_value, int in_step, IssmDouble in_time)
 
 ~GenericExternalResult ()
 
void Echo (void)
 
void DeepEcho (void)
 
Object * copy (void)
 
void WriteData (FILE *fid, bool io_gather)
 
int ObjectEnum (void)
 
double * GetValues (void)
 
void Marshall (char **pmarshalled_data, int *pmarshalled_data_size, int marshall_direction)
 
void Transpose (void)
 
 GenericExternalResult (int in_id, int in_enum_type, Vector< IssmPDouble > *in_values, int in_M, int in_N, int in_step, IssmDouble in_time)
 
 GenericExternalResult (int in_id, int in_enum_type, Vector< IssmPDouble > *in_value, int in_step, IssmDouble in_time)
 
 ~GenericExternalResult ()
 
void Echo (void)
 
void DeepEcho (void)
 
Object * copy (void)
 
int ObjectEnum (void)
 
void WriteData (FILE *fid, bool io_gather)
 
void Marshall (char **pmarshalled_data, int *pmarshalled_data_size, int marshall_direction)
 
- Public Member Functions inherited from ExternalResult
virtual ~ExternalResult ()
 
- Public Member Functions inherited from Object
virtual ~Object ()
 

Private Attributes

int id
 
char * result_name
 
ResultType value
 
int M
 
int N
 
int step
 
IssmDouble time
 

Detailed Description

template<class ResultType>
class GenericExternalResult< ResultType >

Definition at line 21 of file GenericExternalResult.h.

Constructor & Destructor Documentation

◆ GenericExternalResult() [1/16]

template<class ResultType >
GenericExternalResult< ResultType >::GenericExternalResult ( )
inline

Definition at line 79 of file GenericExternalResult.h.

79  { /*{{{*/
80  id = 0;
81  result_name = NULL;
82  M = 0;
83  N = 0;
84  step = 0;
85  time = 0;
86  value = 0;
87  } /*}}}*/

◆ GenericExternalResult() [2/16]

template<class ResultType >
GenericExternalResult< ResultType >::GenericExternalResult ( int  in_id,
int  in_enum_type,
ResultType  in_values,
int  in_M,
int  in_N,
int  in_step,
IssmDouble  in_time 
)
inline

Definition at line 88 of file GenericExternalResult.h.

88  {/*{{{*/
89  id = in_id;
90  step = in_step;
91  time = in_time;
92  M = in_M;
93  N = in_N;
94 
95  /*Copy result in values*/
96  if(M*N){
97  value=xNew<IssmDouble>(M*N);
98  xMemCpy<IssmDouble>(value,in_values,M*N);
99  }
100  else value=NULL;
101 
102  /*Convert enum to name*/
103  EnumToStringx(&this->result_name,in_enum_type);
104  }

◆ GenericExternalResult() [3/16]

template<class ResultType >
GenericExternalResult< ResultType >::GenericExternalResult ( int  in_id,
const char *  name_in,
ResultType  in_values,
int  in_M,
int  in_N,
int  in_step,
IssmDouble  in_time 
)
inline

Definition at line 106 of file GenericExternalResult.h.

106  {/*{{{*/
107  _error_("template GenericExternalResult(int in_id, int in_enum_type,double* in_values, int in_M,int in_N,int in_step,IssmDouble in_time) not implemented for this ResultType\n");
108  }

◆ GenericExternalResult() [4/16]

template<class ResultType >
GenericExternalResult< ResultType >::GenericExternalResult ( int  in_id,
int  in_enum_type,
ResultType  in_value,
int  in_step,
IssmDouble  in_time 
)
inline

Definition at line 110 of file GenericExternalResult.h.

110  { /*{{{*/
111  id = in_id;
112  value = in_value;
113  step = in_step;
114  time = in_time;
115  M = 1;
116  N = 1;
117 
118  /*Convert enum to name*/
119  EnumToStringx(&this->result_name,in_enum_type);
120  }

◆ GenericExternalResult() [5/16]

template<class ResultType >
GenericExternalResult< ResultType >::GenericExternalResult ( int  in_id,
int  in_enum_type,
ResultType  in_value 
)
inline

Definition at line 122 of file GenericExternalResult.h.

122  { /*{{{*/
123  id = in_id;
124  value = in_value;
125  step = UNDEF;
126  time = UNDEF;
127  M = 1;
128  N = 1;
129 
130  /*Convert enum to name*/
131  EnumToStringx(&this->result_name,in_enum_type);
132  }

◆ GenericExternalResult() [6/16]

template<class ResultType >
GenericExternalResult< ResultType >::GenericExternalResult ( int  in_id,
const char *  in_result_name,
ResultType  in_value,
int  in_step,
IssmDouble  in_time 
)
inline

Definition at line 134 of file GenericExternalResult.h.

134  { /*{{{*/
135  id = in_id;
136  value = in_value;
137  step = in_step;
138  time = in_time;
139  M = 1;
140  N = 1;
141 
142  /*Copy name*/
143  this->result_name = xNew<char>(strlen(in_result_name)+1);
144  xMemCpy<char>(this->result_name,in_result_name,strlen(in_result_name)+1);
145  }

◆ ~GenericExternalResult() [1/5]

template<class ResultType >
GenericExternalResult< ResultType >::~GenericExternalResult ( )
inline

Definition at line 147 of file GenericExternalResult.h.

147  { /*{{{*/
148  xDelete<char>(result_name);
149  } /*}}}*/

◆ GenericExternalResult() [7/16]

GenericExternalResult< char * >::GenericExternalResult ( int  in_id,
int  in_enum_type,
char *  in_value,
int  in_step,
IssmDouble  in_time 
)
inline

Definition at line 281 of file GenericExternalResult.h.

281  { /*{{{*/
282 
283  id = in_id;
284  value = xNew<char>(strlen(in_value)+1);
285  xMemCpy<char>(value,in_value,(strlen(in_value)+1));
286  step = in_step;
287  time = in_time;
288  M = 1;
289  N = 1;
290 
291  /*Convert enum to name*/
292  EnumToStringx(&this->result_name,in_enum_type);
293 
294 } /*}}}*/

◆ GenericExternalResult() [8/16]

GenericExternalResult< char * >::GenericExternalResult ( int  in_id,
int  in_enum_type,
char *  in_value 
)
inline

Definition at line 295 of file GenericExternalResult.h.

295  { /*{{{*/
296 
297  id = in_id;
298  value = xNew<char>(strlen(in_value)+1);
299  xMemCpy<char>(value,in_value,(strlen(in_value)+1));
300  step = UNDEF;
301  time = UNDEF;
302 
303  /*Convert enum to name*/
304  EnumToStringx(&this->result_name,in_enum_type);
305 
306 } /*}}}*/

◆ ~GenericExternalResult() [2/5]

GenericExternalResult< char * >::~GenericExternalResult ( )
inline

Definition at line 307 of file GenericExternalResult.h.

307  { /*{{{*/
308  xDelete<char>(result_name);
309  xDelete<char>(value);
310 } /*}}}*/

◆ GenericExternalResult() [9/16]

GenericExternalResult< int * >::GenericExternalResult ( int  in_id,
int  in_enum_type,
int *  in_values,
int  in_M,
int  in_N,
int  in_step,
IssmDouble  in_time 
)
inline

Definition at line 361 of file GenericExternalResult.h.

361  {/*{{{*/
362 
363  id = in_id;
364  M = in_M;
365  N = in_N;
366 
367  EnumToStringx(&this->result_name,in_enum_type);
368 
369  step = in_step;
370  time = in_time;
371 
372  /*Copy result in values*/
373  if(M*N){
374  value=xNew<int>(M*N);
375  xMemCpy<int>(value,in_values,M*N);
376  }
377  else value=NULL;
378 }

◆ GenericExternalResult() [10/16]

GenericExternalResult< int * >::GenericExternalResult ( int  in_id,
const char *  in_result_name,
int *  in_values,
int  in_M,
int  in_N,
int  in_step,
IssmDouble  in_time 
)
inline

Definition at line 380 of file GenericExternalResult.h.

380  {/*{{{*/
381 
382  id = in_id;
383  M = in_M;
384  N = in_N;
385 
386  /*Copy name*/
387  this->result_name = xNew<char>(strlen(in_result_name)+1);
388  xMemCpy<char>(this->result_name,in_result_name,strlen(in_result_name)+1);
389 
390  step = in_step;
391  time = in_time;
392 
393  /*Copy result in values*/
394  if(M*N){
395  value=xNew<int>(M*N);
396  xMemCpy<int>(value,in_values,M*N);
397  }
398  else value=NULL;
399 }

◆ GenericExternalResult() [11/16]

GenericExternalResult< int * >::GenericExternalResult ( int  in_id,
int  in_enum_type,
int *  in_value,
int  in_step,
IssmDouble  in_time 
)
inline

Definition at line 401 of file GenericExternalResult.h.

401  { /*{{{*/
402  _error_("you cannot initialize a GenericExternalResult<int*> without providing the dimensions of the matrix! Please use a more appropriate constructor!");
403 } /*}}}*/

◆ ~GenericExternalResult() [3/5]

GenericExternalResult< int * >::~GenericExternalResult ( )
inline

Definition at line 404 of file GenericExternalResult.h.

404  { /*{{{*/
405  xDelete<char>(result_name);
406  xDelete<int>(value);
407 } /*}}}*/

◆ GenericExternalResult() [12/16]

GenericExternalResult< IssmPDouble * >::GenericExternalResult ( int  in_id,
int  in_enum_type,
IssmPDouble *  in_values,
int  in_M,
int  in_N,
int  in_step,
IssmDouble  in_time 
)
inline

Definition at line 490 of file GenericExternalResult.h.

490  {/*{{{*/
491 
492  id = in_id;
493  M = in_M;
494  N = in_N;
495 
496  EnumToStringx(&this->result_name,in_enum_type);
497 
498  step = in_step;
499  time = in_time;
500 
501  /*Copy result in values*/
502  if(M*N){
503  value=xNew<IssmPDouble>(M*N);
504  xMemCpy<IssmPDouble>(value,in_values,M*N);
505  }
506  else value=NULL;
507 }

◆ GenericExternalResult() [13/16]

GenericExternalResult< IssmPDouble * >::GenericExternalResult ( int  in_id,
const char *  in_result_name,
IssmPDouble *  in_values,
int  in_M,
int  in_N,
int  in_step,
IssmDouble  in_time 
)
inline

Definition at line 509 of file GenericExternalResult.h.

509  {/*{{{*/
510 
511  id = in_id;
512  M = in_M;
513  N = in_N;
514 
515  /*Copy name*/
516  this->result_name = xNew<char>(strlen(in_result_name)+1);
517  xMemCpy<char>(this->result_name,in_result_name,strlen(in_result_name)+1);
518 
519  step = in_step;
520  time = in_time;
521 
522  /*Copy result in values*/
523  if(M*N){
524  value=xNew<IssmPDouble>(M*N);
525  xMemCpy<IssmPDouble>(value,in_values,M*N);
526  }
527  else value=NULL;
528 }

◆ GenericExternalResult() [14/16]

GenericExternalResult< IssmPDouble * >::GenericExternalResult ( int  in_id,
int  in_enum_type,
IssmPDouble *  in_value,
int  in_step,
IssmDouble  in_time 
)
inline

Definition at line 530 of file GenericExternalResult.h.

530  { /*{{{*/
531  _error_("you cannot initialize a GenericExternalResult<IssmPDouble*> without providing the dimensions of the matrix! Please use a more appropriate constructor!");
532 } /*}}}*/

◆ ~GenericExternalResult() [4/5]

GenericExternalResult< IssmPDouble * >::~GenericExternalResult ( )
inline

Definition at line 533 of file GenericExternalResult.h.

533  { /*{{{*/
534  xDelete<char>(result_name);
535  xDelete<IssmPDouble>(value);
536 } /*}}}*/

◆ GenericExternalResult() [15/16]

GenericExternalResult< Vector< IssmPDouble > * >::GenericExternalResult ( int  in_id,
int  in_enum_type,
Vector< IssmPDouble > *  in_values,
int  in_M,
int  in_N,
int  in_step,
IssmDouble  in_time 
)
inline

Definition at line 696 of file GenericExternalResult.h.

696  {/*{{{*/
697  _error_("instanciation not correct");
698  }

◆ GenericExternalResult() [16/16]

GenericExternalResult< Vector< IssmPDouble > * >::GenericExternalResult ( int  in_id,
int  in_enum_type,
Vector< IssmPDouble > *  in_value,
int  in_step,
IssmDouble  in_time 
)
inline

Definition at line 700 of file GenericExternalResult.h.

700  { /*{{{*/
701  id = in_id;
702  M = 0;
703  N = 0;
704 
705  /*Convert enum to name*/
706  EnumToStringx(&this->result_name,in_enum_type);
707 
708  step = in_step;
709  time = in_time;
710 
711  value = in_value;
712  } /*}}}*/

◆ ~GenericExternalResult() [5/5]

GenericExternalResult< Vector< IssmPDouble > * >::~GenericExternalResult ( )
inline

Definition at line 713 of file GenericExternalResult.h.

713  { /*{{{*/
714  xDelete<char>(this->result_name);
715  delete value;
716  } /*}}}*/

Member Function Documentation

◆ GenericEcho()

template<class ResultType >
void GenericExternalResult< ResultType >::GenericEcho ( void  )
inline

Definition at line 34 of file GenericExternalResult.h.

34  {/*{{{*/
35  _printf_(" id : " << this->id << "\n");
36  _printf_(" result_name : " << this->result_name<< "\n");
37  _printf_(" step : " << this->step << "\n");
38  _printf_(" time : " << this->time << "\n");
39  }

◆ GenericWriteData()

template<class ResultType >
void GenericExternalResult< ResultType >::GenericWriteData ( FILE *  fid)
inline

Definition at line 41 of file GenericExternalResult.h.

41  {/*{{{*/
42 
43  IssmPDouble passiveDouble;
44 
45  /*First write name: */
46  int length=(strlen(this->result_name)+1)*sizeof(char);
47  fwrite(&length,sizeof(int),1,fid);
48  fwrite(this->result_name,length,1,fid);
49 
50  /*Now write time and step: */
51  passiveDouble=reCast<IssmPDouble>(time);
52  fwrite(&passiveDouble,sizeof(IssmPDouble),1,fid);
53  fwrite(&step,sizeof(int),1,fid);
54  } /*}}}*/

◆ GenericMarshall()

template<class ResultType >
void GenericExternalResult< ResultType >::GenericMarshall ( char **  pmarshalled_data,
int *  pmarshalled_data_size,
int  marshall_direction 
)
inline

Definition at line 55 of file GenericExternalResult.h.

55  {/*{{{*/
56 
57  MARSHALLING_ENUM(this->ObjectEnum());
58  MARSHALLING(id);
59  MARSHALLING(step);
60  MARSHALLING(time);
61 
62  /*Marshal result name*/
63  int size = 0;
64  if(marshall_direction==MARSHALLING_FORWARD || marshall_direction == MARSHALLING_SIZE) size=strlen(result_name)+1;
65  MARSHALLING(size);
66  MARSHALLING_DYNAMIC(result_name,char,size);
67 
68  /*Marshall value*/
69  this->value=0;
70  bool isnull=true;
71  if(marshall_direction==MARSHALLING_FORWARD || marshall_direction == MARSHALLING_SIZE){
72  if(value) isnull=false;
73  }
74  MARSHALLING(isnull);
75  if(!isnull){MARSHALLING(value);}
76  } /*}}}*/

◆ copy() [1/4]

template<class ResultType >
Object* GenericExternalResult< ResultType >::copy ( void  )
inlinevirtual

Implements Object.

Definition at line 152 of file GenericExternalResult.h.

152  { /*{{{*/
153  return new GenericExternalResult<ResultType>(this->id,this->result_name,this->value,this->step,this->time);
154  } /*}}}*/

◆ Echo() [1/4]

template<class ResultType >
void GenericExternalResult< ResultType >::Echo ( void  )
inlinevirtual

Implements Object.

Definition at line 155 of file GenericExternalResult.h.

155  { /*{{{*/
156  this->DeepEcho();
157  }

◆ DeepEcho() [1/8]

template<class ResultType >
void GenericExternalResult< ResultType >::DeepEcho ( void  )
inlinevirtual

Implements Object.

Definition at line 159 of file GenericExternalResult.h.

159  { /*{{{*/
160  _error_("template DeepEcho not implemented for this ResultType\n");
161  }

◆ Id()

template<class ResultType >
int GenericExternalResult< ResultType >::Id ( void  )
inlinevirtual

Implements Object.

Definition at line 163 of file GenericExternalResult.h.

163  { /*{{{*/
164  return -1;
165  } /*}}}*/

◆ ObjectEnum() [1/8]

template<class ResultType >
int GenericExternalResult< ResultType >::ObjectEnum ( void  )
inlinevirtual

Implements Object.

Definition at line 166 of file GenericExternalResult.h.

166  { /*{{{*/
167  _error_("template ObjectEnum not implemented for this ResultType\n");
168  } /*}}}*/

◆ Marshall() [1/8]

template<class ResultType >
void GenericExternalResult< ResultType >::Marshall ( char **  pmarshalled_data,
int *  pmarshalled_data_size,
int  marshall_direction 
)
inlinevirtual

Implements Object.

Definition at line 169 of file GenericExternalResult.h.

169  {/*{{{*/
170  _error_("not implemented yet!");
171  }

◆ WriteData() [1/5]

template<class ResultType >
void GenericExternalResult< ResultType >::WriteData ( FILE *  fid,
bool  io_gather 
)
inlinevirtual

Implements ExternalResult.

Definition at line 175 of file GenericExternalResult.h.

175  { /*{{{*/
176 
177  int my_rank;
178  int type;
179  int size;
180  IssmPDouble passiveDouble;
181 
182  /*recover my_rank:*/
183  my_rank=IssmComm::GetRank();
184 
185  /*return if now on cpu 0: */
186  if(my_rank)return;
187 
188  /*use generic part, same for all ResultTypes: */
189  this->GenericWriteData(fid);
190 
191  /*writing a IssmPDouble for Matlab or Python to post-process, type is 1, size is 1: */
192  type=1;
193  size=1;
194  fwrite(&type,sizeof(int),1,fid);
195  fwrite(&size,sizeof(int),1,fid);
196 
197  /*cast to a IssmPDouble: */
198  passiveDouble=reCast<IssmPDouble>(value);
199  fwrite(&passiveDouble,size*sizeof(IssmPDouble),1,fid);
200 
201 } /*}}}*/

◆ Transpose() [1/2]

template<class ResultType >
void GenericExternalResult< ResultType >::Transpose ( void  )
inline

Definition at line 202 of file GenericExternalResult.h.

202  { /*{{{*/
203  _error_("not implemented yet");
204 } /*}}}*/

◆ GetResultName()

template<class ResultType >
char* GenericExternalResult< ResultType >::GetResultName ( void  )
inlinevirtual

Implements ExternalResult.

Definition at line 205 of file GenericExternalResult.h.

205  { /*{{{*/
206  char* name = xNew<char>(strlen(this->result_name)+1);
207  xMemCpy<char>(name,this->result_name,strlen(this->result_name)+1);
208  return name;
209 } /*}}}*/

◆ GetResultEnum()

template<class ResultType >
int GenericExternalResult< ResultType >::GetResultEnum ( void  )
inlinevirtual

Implements ExternalResult.

Definition at line 210 of file GenericExternalResult.h.

210  { /*{{{*/
211  return StringToEnumx(this->result_name,false);
212 } /*}}}*/

◆ GetStep()

template<class ResultType >
int GenericExternalResult< ResultType >::GetStep ( void  )
inlinevirtual

Implements ExternalResult.

Definition at line 213 of file GenericExternalResult.h.

213  { /*{{{*/
214  return this->step;
215 } /*}}}*/

◆ GetValue() [1/2]

template<class ResultType >
double GenericExternalResult< ResultType >::GetValue ( void  )
inlinevirtual

Implements ExternalResult.

Definition at line 216 of file GenericExternalResult.h.

216  { /*{{{*/
217  /*Only supported by IssmPDouble result, error out by default*/
218  _error_("not supported for this type of result");
219 } /*}}}*/

◆ GetValues() [1/2]

template<class ResultType >
double* GenericExternalResult< ResultType >::GetValues ( void  )
inline

Definition at line 220 of file GenericExternalResult.h.

220  { /*{{{*/
221  /*Only supported by IssmPDouble* result, error out by default*/
222  _error_("not supported for this type of result");
223 } /*}}}*/

◆ DeepEcho() [2/8]

void GenericExternalResult< bool >::DeepEcho ( void  )
inlinevirtual

Implements Object.

Definition at line 227 of file GenericExternalResult.h.

227  { /*{{{*/
228 
229  _printf_("GenericExternalResult<bool>:\n");
230  this->GenericEcho();
231  _printf_(" value: " <<(this->value?"true":"false") << "\n");
232 
233 } /*}}}*/

◆ ObjectEnum() [2/8]

int GenericExternalResult< bool >::ObjectEnum ( void  )
inlinevirtual

Implements Object.

Definition at line 234 of file GenericExternalResult.h.

234  { /*{{{*/
235  return BoolExternalResultEnum;
236 } /*}}}*/

◆ Marshall() [2/8]

void GenericExternalResult< bool >::Marshall ( char **  pmarshalled_data,
int *  pmarshalled_data_size,
int  marshall_direction 
)
inlinevirtual

Implements Object.

Definition at line 237 of file GenericExternalResult.h.

237  {/*{{{*/
238 
239  this->GenericMarshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
240 
241 } /*}}}*/

◆ DeepEcho() [3/8]

void GenericExternalResult< int >::DeepEcho ( void  )
inlinevirtual

Implements Object.

Definition at line 244 of file GenericExternalResult.h.

244  { /*{{{*/
245 
246  _printf_("GenericExternalResult<int>:\n");
247  this->GenericEcho();
248  _printf_(" value: " << this->value << "\n");
249 
250 } /*}}}*/

◆ ObjectEnum() [3/8]

int GenericExternalResult< int >::ObjectEnum ( void  )
inlinevirtual

Implements Object.

Definition at line 251 of file GenericExternalResult.h.

251  { /*{{{*/
252  return IntExternalResultEnum;
253 } /*}}}*/

◆ Marshall() [3/8]

void GenericExternalResult< int >::Marshall ( char **  pmarshalled_data,
int *  pmarshalled_data_size,
int  marshall_direction 
)
inlinevirtual

Implements Object.

Definition at line 254 of file GenericExternalResult.h.

254  {/*{{{*/
255 
256  this->GenericMarshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
257 
258 } /*}}}*/

◆ DeepEcho() [4/8]

void GenericExternalResult< double >::DeepEcho ( void  )
inlinevirtual

Implements Object.

Definition at line 261 of file GenericExternalResult.h.

261  { /*{{{*/
262 
263  _printf_("GenericExternalResult<double>:\n");
264  this->GenericEcho();
265  _printf_(" value: " << this->value << "\n");
266 
267 } /*}}}*/

◆ ObjectEnum() [4/8]

int GenericExternalResult< double >::ObjectEnum ( void  )
inlinevirtual

Implements Object.

Definition at line 268 of file GenericExternalResult.h.

268  { /*{{{*/
269  return DoubleExternalResultEnum;
270 } /*}}}*/

◆ GetValue() [2/2]

double GenericExternalResult< double >::GetValue ( void  )
inlinevirtual

Implements ExternalResult.

Definition at line 271 of file GenericExternalResult.h.

271  { /*{{{*/
272  return value;
273 } /*}}}*/

◆ Marshall() [4/8]

void GenericExternalResult< double >::Marshall ( char **  pmarshalled_data,
int *  pmarshalled_data_size,
int  marshall_direction 
)
inlinevirtual

Implements Object.

Definition at line 274 of file GenericExternalResult.h.

274  {/*{{{*/
275 
276  this->GenericMarshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
277 
278 } /*}}}*/

◆ DeepEcho() [5/8]

void GenericExternalResult< char * >::DeepEcho ( void  )
inlinevirtual

Implements Object.

Definition at line 311 of file GenericExternalResult.h.

311  { /*{{{*/
312 
313  _printf_("GenericExternalResult<char*>:\n");
314  this->GenericEcho();
315  _printf_(" value: " << this->value << "\n");
316 
317 } /*}}}*/

◆ WriteData() [2/5]

void GenericExternalResult< char * >::WriteData ( FILE *  fid,
bool  io_gather 
)
inlinevirtual

Implements ExternalResult.

Definition at line 318 of file GenericExternalResult.h.

318  { /*{{{*/
319 
320  int my_rank;
321  int type;
322  int length;
323 
324  /*recover my_rank:*/
325  my_rank=IssmComm::GetRank();
326 
327  /*return if now on cpu 0: */
328  if(my_rank)return;
329 
330  /*use generic part, same for all ResultTypes: */
331  this->GenericWriteData(fid);
332 
333  /*writing a string, type is 2: */
334  type=2;
335  fwrite(&type,sizeof(int),1,fid);
336 
337  length=(strlen(this->value)+1)*sizeof(char);
338  fwrite(&length,sizeof(int),1,fid);
339  fwrite(this->value,length,1,fid);
340 }

◆ ObjectEnum() [5/8]

int GenericExternalResult< char * >::ObjectEnum ( void  )
inlinevirtual

Implements Object.

Definition at line 342 of file GenericExternalResult.h.

342  { /*{{{*/
343  return StringExternalResultEnum;
344 } /*}}}*/

◆ Marshall() [5/8]

void GenericExternalResult< char * >::Marshall ( char **  pmarshalled_data,
int *  pmarshalled_data_size,
int  marshall_direction 
)
inlinevirtual

Implements Object.

Definition at line 345 of file GenericExternalResult.h.

345  {/*{{{*/
346 
347  int size = 0;
348 
349  if(marshall_direction==MARSHALLING_FORWARD || marshall_direction == MARSHALLING_SIZE)size=strlen(value)+1;
350 
351  MARSHALLING(id);
352  MARSHALLING(result_name);
353  MARSHALLING(size);
354  MARSHALLING_DYNAMIC(value,char,size);
355  MARSHALLING(step);
356  MARSHALLING(time);
357 
358 } /*}}}*/

◆ Echo() [2/4]

void GenericExternalResult< int * >::Echo ( void  )
inlinevirtual

Implements Object.

Definition at line 408 of file GenericExternalResult.h.

408  { /*{{{*/
409 
410  _printf_("GenericExternalResult<int*>:\n");
411  this->GenericEcho();
412  _printf_(" matrix size: " << this->M << "-" << this->N << "\n");
413 
414 } /*}}}*/

◆ DeepEcho() [6/8]

void GenericExternalResult< int * >::DeepEcho ( void  )
inlinevirtual

Implements Object.

Definition at line 415 of file GenericExternalResult.h.

415  { /*{{{*/
416 
417  int i,j;
418 
419  _printf_("GenericExternalResult<int*>:\n");
420  this->GenericEcho();
421 
422  _printf_(" matrix size: " << this->M << "-" << this->N << "\n");
423  for (i=0;i<this->M;i++){
424  _printf_(" [ ");
425  for (j=0;j<this->N;j++){
426  _printf_( " " << setw(11) << this->value[i*this->N+j]);
427  }
428  _printf_(" ]\n");
429  }
430 
431 } /*}}}*/

◆ copy() [2/4]

Object * GenericExternalResult< int * >::copy ( void  )
inlinevirtual

Implements Object.

Definition at line 432 of file GenericExternalResult.h.

432  { /*{{{*/
433  return new GenericExternalResult<int*>(this->id,StringToEnumx(this->result_name),this->value,this->M,this->N,this->step,this->time);
434 } /*}}}*/

◆ WriteData() [3/5]

void GenericExternalResult< int * >::WriteData ( FILE *  fid,
bool  io_gather 
)
inlinevirtual

Implements ExternalResult.

Definition at line 435 of file GenericExternalResult.h.

435  { /*{{{*/
436 
437  int my_rank;
438  int type;
439  int rows,cols;
440  char *name = NULL;
441  IssmPDouble passiveDouble;
442 
443  /*recover my_rank:*/
444  my_rank=IssmComm::GetRank();
445 
446  if(io_gather){
447  /*we are gathering the data on cpu 0, don't write on other cpus: */
448  if(my_rank) return;
449  }
450 
451  /*First write enum: */
452  int length=(strlen(this->result_name)+1)*sizeof(char);
453  fwrite(&length,sizeof(int),1,fid);
454  fwrite(this->result_name,length,1,fid);
455 
456  /*Now write time and step: */
457  passiveDouble=reCast<IssmPDouble>(time);
458  fwrite(&passiveDouble,sizeof(IssmPDouble),1,fid);
459  fwrite(&step,sizeof(int),1,fid);
460 
461  /*writing an int array, type is 4 (see parseresultsfromdisk.m):*/
462  type=4;
463  fwrite(&type,sizeof(int),1,fid);
464  rows=this->M;
465  fwrite(&rows,sizeof(int),1,fid);
466  cols=this->N;
467  fwrite(&cols,sizeof(int),1,fid);
468  fwrite(value,cols*rows*sizeof(int),1,fid);
469 
470 }

◆ ObjectEnum() [6/8]

int GenericExternalResult< int * >::ObjectEnum ( void  )
inlinevirtual

Implements Object.

Definition at line 472 of file GenericExternalResult.h.

472  { /*{{{*/
473  return IntMatExternalResultEnum;
474 } /*}}}*/

◆ Marshall() [6/8]

void GenericExternalResult< int * >::Marshall ( char **  pmarshalled_data,
int *  pmarshalled_data_size,
int  marshall_direction 
)
inlinevirtual

Implements Object.

Definition at line 475 of file GenericExternalResult.h.

475  {/*{{{*/
476 
477  MARSHALLING_ENUM(this->ObjectEnum());
478 
479  MARSHALLING(id);
480  MARSHALLING(result_name);
481  MARSHALLING(M);
482  MARSHALLING(N);
483  MARSHALLING_DYNAMIC(value,int,M*N);
484  MARSHALLING(step);
485  MARSHALLING(time);
486 
487 } /*}}}*/

◆ Echo() [3/4]

void GenericExternalResult< IssmPDouble * >::Echo ( void  )
inlinevirtual

Implements Object.

Definition at line 537 of file GenericExternalResult.h.

537  { /*{{{*/
538 
539  _printf_("GenericExternalResult<IssmPDouble*>:\n");
540  this->GenericEcho();
541  _printf_(" matrix size: " << this->M << "-" << this->N << "\n");
542 
543 } /*}}}*/

◆ DeepEcho() [7/8]

void GenericExternalResult< IssmPDouble * >::DeepEcho ( void  )
inlinevirtual

Implements Object.

Definition at line 544 of file GenericExternalResult.h.

544  { /*{{{*/
545 
546  int i,j;
547 
548  _printf_("GenericExternalResult<IssmPDouble*>:\n");
549  this->GenericEcho();
550 
551  _printf_(" matrix size: " << this->M << "-" << this->N << "\n");
552  for (i=0;i<this->M;i++){
553  _printf_(" [ ");
554  for (j=0;j<this->N;j++){
555  _printf_( " " << setw(11) << setprecision (5) << this->value[i*this->N+j]);
556  }
557  _printf_(" ]\n");
558  }
559 
560 } /*}}}*/

◆ copy() [3/4]

Object * GenericExternalResult< IssmPDouble * >::copy ( void  )
inlinevirtual

Implements Object.

Definition at line 561 of file GenericExternalResult.h.

561  { /*{{{*/
562  return new GenericExternalResult<IssmPDouble*>(this->id,StringToEnumx(this->result_name),this->value,this->M,this->N,this->step,this->time);
563 } /*}}}*/

◆ WriteData() [4/5]

void GenericExternalResult< IssmPDouble * >::WriteData ( FILE *  fid,
bool  io_gather 
)
inlinevirtual

Implements ExternalResult.

Definition at line 564 of file GenericExternalResult.h.

564  { /*{{{*/
565 
566  int my_rank;
567  int type;
568  int rows,cols;
569  char *name = NULL;
570  IssmPDouble passiveDouble;
571 
572  /*recover my_rank:*/
573  my_rank=IssmComm::GetRank();
574 
575  if(io_gather){
576  /*we are gathering the data on cpu 0, don't write on other cpus: */
577  if(my_rank) return;
578  }
579 
580  /*First write enum: */
581  int length=(strlen(this->result_name)+1)*sizeof(char);
582  fwrite(&length,sizeof(int),1,fid);
583  fwrite(this->result_name,length,1,fid);
584 
585  /*Now write time and step: */
586  passiveDouble=reCast<IssmPDouble>(time);
587  fwrite(&passiveDouble,sizeof(IssmPDouble),1,fid);
588  fwrite(&step,sizeof(int),1,fid);
589 
590  /*writing a IssmDouble array, type is 3:*/
591  type=3;
592  fwrite(&type,sizeof(int),1,fid);
593  rows=this->M;
594  fwrite(&rows,sizeof(int),1,fid);
595  cols=this->N;
596  fwrite(&cols,sizeof(int),1,fid);
597  fwrite(value,cols*rows*sizeof(IssmPDouble),1,fid);
598 
599 }

◆ ObjectEnum() [7/8]

int GenericExternalResult< IssmPDouble * >::ObjectEnum ( void  )
inlinevirtual

Implements Object.

Definition at line 601 of file GenericExternalResult.h.

601  { /*{{{*/
602  return DoubleMatExternalResultEnum;
603 } /*}}}*/

◆ GetValues() [2/2]

double * GenericExternalResult< IssmPDouble * >::GetValues ( void  )
inline

Definition at line 604 of file GenericExternalResult.h.

604  { /*{{{*/
605  return value;
606 } /*}}}*/

◆ Marshall() [7/8]

void GenericExternalResult< IssmPDouble * >::Marshall ( char **  pmarshalled_data,
int *  pmarshalled_data_size,
int  marshall_direction 
)
inlinevirtual

Implements Object.

Definition at line 607 of file GenericExternalResult.h.

607  {/*{{{*/
608 
609  MARSHALLING_ENUM(this->ObjectEnum());
610 
611  MARSHALLING(id);
612  MARSHALLING(result_name);
613  MARSHALLING(M);
614  MARSHALLING(N);
615  MARSHALLING_DYNAMIC(value,IssmPDouble,M*N);
616  MARSHALLING(step);
617  MARSHALLING(time);
618 
619 } /*}}}*/

◆ Transpose() [2/2]

void GenericExternalResult< IssmPDouble * >::Transpose ( void  )
inline

Definition at line 620 of file GenericExternalResult.h.

620  {/*{{{*/
621 
622 
623  /*Perform transpose only if we have a matrix*/
624  if(M>1 && N>1){
625  IssmPDouble* temp=xNew<IssmPDouble>(M*N);
626  for(int i=0;i<M;i++){
627  for(int j=0;j<N;j++){
628  temp[j*M+i] = value[i*N+j];
629  }
630  }
631  xDelete<IssmPDouble>(this->value);
632  this->value = temp;
633  }
634 
635  /*Switch dimensions*/
636  int temp2 = this->N;
637  this->N = this->M;
638  this->M = temp2;
639 
640 
641 
642 } /*}}}*/

◆ Echo() [4/4]

void GenericExternalResult< Vector< IssmPDouble > * >::Echo ( void  )
inlinevirtual

Implements Object.

Definition at line 717 of file GenericExternalResult.h.

717  { /*{{{*/
718 
719  _printf_("GenericExternalResult<Vector<IssmPDouble>*>:\n");
720  this->GenericEcho();
721  this->value->Echo();
722 
723  } /*}}}*/

◆ DeepEcho() [8/8]

void GenericExternalResult< Vector< IssmPDouble > * >::DeepEcho ( void  )
inlinevirtual

Implements Object.

Definition at line 724 of file GenericExternalResult.h.

724  { /*{{{*/
725 
726  this->Echo();
727 
728  } /*}}}*/

◆ copy() [4/4]

Object * GenericExternalResult< Vector< IssmPDouble > * >::copy ( void  )
inlinevirtual

Implements Object.

Definition at line 729 of file GenericExternalResult.h.

729  { /*{{{*/
730  return new GenericExternalResult<Vector<IssmPDouble>*>(this->id,StringToEnumx(this->result_name),this->value,this->step,this->time);
731  } /*}}}*/

◆ ObjectEnum() [8/8]

int GenericExternalResult< Vector< IssmPDouble > * >::ObjectEnum ( void  )
inlinevirtual

Implements Object.

Definition at line 776 of file GenericExternalResult.h.

776  { /*{{{*/
777  return NoneEnum;
778  /*???? FIXME*/
779  } /*}}}*/

◆ WriteData() [5/5]

void GenericExternalResult< Vector< IssmDouble > * >::WriteData ( FILE *  fid,
bool  io_gather 
)
inlinevirtual

Implements ExternalResult.

Definition at line 782 of file GenericExternalResult.h.

782  { /*{{{*/
783 
784  int i;
785  char *name = NULL;
786  int length,rows,cols=1;
787  IssmDouble* serialvalues = NULL;
788  IssmPDouble* pserialvalues = NULL;
789 
790  if(!io_gather){
791  _error_("not supported yet");
792  }
793 
794  /*Serialize vector only on cpu0*/
795  serialvalues = this->value->ToMPISerial0();
796 
797  if(IssmComm::GetRank()==0){
798 
799  /*Make it passive*/
800  this->value->GetSize(&rows);
801  pserialvalues=xNew<IssmPDouble>(rows);
802  for(i=0;i<rows;i++)pserialvalues[i]=reCast<IssmPDouble>(serialvalues[i]);
803 
804  /*First write name: */
805  length=(strlen(this->result_name)+1)*sizeof(char);
806  fwrite(&length,sizeof(int),1,fid);
807  fwrite(this->result_name,length,1,fid);
808 
809  /*Now write time and step: */
810  IssmPDouble passiveDouble=reCast<IssmPDouble>(time);
811  fwrite(&passiveDouble,sizeof(IssmPDouble),1,fid);
812  fwrite(&step,sizeof(int),1,fid);
813 
814  /*writing a IssmDouble array, type is 3:*/
815  int type=3;
816  fwrite(&type,sizeof(int),1,fid);
817  fwrite(&rows,sizeof(int),1,fid);
818  fwrite(&cols,sizeof(int),1,fid);
819  fwrite(pserialvalues,cols*rows*sizeof(IssmPDouble),1,fid);
820 
821  /*Clean up*/
822  xDelete<IssmPDouble>(pserialvalues);
823  }
824 
825  /*Clean up*/
826  xDelete<IssmDouble>(serialvalues);
827  }

◆ Marshall() [8/8]

void GenericExternalResult< Vector< IssmDouble > * >::Marshall ( char **  pmarshalled_data,
int *  pmarshalled_data_size,
int  marshall_direction 
)
inlinevirtual

Implements Object.

Definition at line 829 of file GenericExternalResult.h.

829  {/*{{{*/
830 
831  _error_("GenericExternalResult instantiated for type Vector<IssmDouble>* called " << result_name << " not implemented yet");
832 
833  } /*}}}*/

Field Documentation

◆ id

template<class ResultType >
int GenericExternalResult< ResultType >::id
private

Definition at line 24 of file GenericExternalResult.h.

◆ result_name

template<class ResultType >
char* GenericExternalResult< ResultType >::result_name
private

Definition at line 25 of file GenericExternalResult.h.

◆ value

template<class ResultType >
ResultType GenericExternalResult< ResultType >::value
private

Definition at line 26 of file GenericExternalResult.h.

◆ M

template<class ResultType >
int GenericExternalResult< ResultType >::M
private

Definition at line 27 of file GenericExternalResult.h.

◆ N

template<class ResultType >
int GenericExternalResult< ResultType >::N
private

Definition at line 28 of file GenericExternalResult.h.

◆ step

template<class ResultType >
int GenericExternalResult< ResultType >::step
private

Definition at line 29 of file GenericExternalResult.h.

◆ time

template<class ResultType >
IssmDouble GenericExternalResult< ResultType >::time
private

Definition at line 30 of file GenericExternalResult.h.

The documentation for this class was generated from the following file:
GenericExternalResult::result_name
char * result_name
Definition: GenericExternalResult.h:25
GenericExternalResult::value
ResultType value
Definition: GenericExternalResult.h:26
IssmDouble
double IssmDouble
Definition: types.h:37
DoubleMatExternalResultEnum
@ DoubleMatExternalResultEnum
Definition: EnumDefinitions.h:1045
GenericExternalResult::DeepEcho
void DeepEcho(void)
Definition: GenericExternalResult.h:159
_printf_
#define _printf_(StreamArgs)
Definition: Print.h:22
IntMatExternalResultEnum
@ IntMatExternalResultEnum
Definition: EnumDefinitions.h:1126
MARSHALLING_ENUM
#define MARSHALLING_ENUM(EN)
Definition: Marshalling.h:14
MARSHALLING_SIZE
@ MARSHALLING_SIZE
Definition: Marshalling.h:11
GenericExternalResult::Echo
void Echo(void)
Definition: GenericExternalResult.h:155
GenericExternalResult::step
int step
Definition: GenericExternalResult.h:29
GenericExternalResult::N
int N
Definition: GenericExternalResult.h:28
MARSHALLING_DYNAMIC
#define MARSHALLING_DYNAMIC(FIELD, TYPE, SIZE)
Definition: Marshalling.h:61
EnumToStringx
const char * EnumToStringx(int enum_in)
Definition: EnumToStringx.cpp:15
GenericExternalResult::M
int M
Definition: GenericExternalResult.h:27
BoolExternalResultEnum
@ BoolExternalResultEnum
Definition: EnumDefinitions.h:993
GenericExternalResult::GenericMarshall
void GenericMarshall(char **pmarshalled_data, int *pmarshalled_data_size, int marshall_direction)
Definition: GenericExternalResult.h:55
UNDEF
#define UNDEF
Definition: constants.h:8
MARSHALLING
#define MARSHALLING(FIELD)
Definition: Marshalling.h:29
StringToEnumx
int StringToEnumx(const char *string_in, bool notfounderror=true)
Definition: StringToEnumx.cpp:14
IntExternalResultEnum
@ IntExternalResultEnum
Definition: EnumDefinitions.h:1120
GenericExternalResult::ObjectEnum
int ObjectEnum(void)
Definition: GenericExternalResult.h:166
GenericExternalResult
Definition: GenericExternalResult.h:21
IssmComm::GetRank
static int GetRank(void)
Definition: IssmComm.cpp:34
NoneEnum
@ NoneEnum
Definition: EnumDefinitions.h:1202
_error_
#define _error_(StreamArgs)
Definition: exceptions.h:49
StringExternalResultEnum
@ StringExternalResultEnum
Definition: EnumDefinitions.h:1291
GenericExternalResult::GenericEcho
void GenericEcho(void)
Definition: GenericExternalResult.h:34
MARSHALLING_FORWARD
@ MARSHALLING_FORWARD
Definition: Marshalling.h:9
DoubleExternalResultEnum
@ DoubleExternalResultEnum
Definition: EnumDefinitions.h:1042
GenericExternalResult::GenericWriteData
void GenericWriteData(FILE *fid)
Definition: GenericExternalResult.h:41
GenericExternalResult::id
int id
Definition: GenericExternalResult.h:24
IssmPDouble
IssmDouble IssmPDouble
Definition: types.h:38
GenericExternalResult::time
IssmDouble time
Definition: GenericExternalResult.h:30
Generated on Thu Jul 2 2020 08:09:28 for Ice Sheet System Model by   doxygen 1.8.19