Changeset aeb9725 in OpenModelica


Ignore:
Timestamp:
2017-10-17T11:02:18+02:00 (7 years ago)
Author:
hudson <openmodelica@…>
Branches:
Added-citation-metadata, maintenance/v1.14, maintenance/v1.15, maintenance/v1.16, maintenance/v1.17, maintenance/v1.18, maintenance/v1.19, maintenance/v1.20, maintenance/v1.21, maintenance/v1.22, maintenance/v1.23, master, omlib-staging
Children:
702e338
Parents:
92ac5a6
git-author:
Martin Sjölund <martin.sjolund@…> (10/17/17 10:02:15)
git-committer:
hudson <openmodelica@…> (10/17/17 11:02:18)
Message:

Add support for single precision in mat4 output

This resolves (part of) ticket:4569

Belonging to [master]:

  • OpenModelica/OMCompiler#1913
  • OpenModelica/OpenModelica-testsuite#746
Location:
SimulationRuntime/c
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • SimulationRuntime/c/simulation/results/simulation_result_mat.cpp

    rbef320c raeb9725  
    4646extern "C" {
    4747
     48typedef enum {
     49  MAT4_DOUBLE_PRECISION_FULL_MATRIX=0,
     50  MAT4_SINGLE_PRECISION_FULL_MATRIX,
     51  MAT4_32BIT_INTEGER_FULL_MATRIX,
     52  MAT4_16BIT_INTEGER_FULL_MATRIX,
     53  MAT4_8BIT_INTEGER_FULL_MATRIX,
     54  MAT4_STRING_TEXT_MATRIX,
     55  MAT4_MATRIX_TYPE_MAX
     56} MAT4_MATRIX_TYPE;
     57
     58static const int MAT4_MOPT_OF_MATRIX_TYPE[MAT4_MATRIX_TYPE_MAX]={0,10,20,30,40,51};
     59static const int MAT4_SIZE_OF_MATRIX_TYPE[MAT4_MATRIX_TYPE_MAX]={8,4,4,2,1,1};
     60
    4861typedef std::pair<void*,int> indx_type;
    4962typedef std::map<int,int> INTMAP;
    … …  
    7083
    7184static long flattenStrBuf(int dims, const struct VAR_INFO** src, char* &dest, int& longest, int& nstrings, bool fixNames, bool useComment);
    72 static void mat_writeMatVer4MatrixHeader(simulation_result *self,DATA *data, threadData_t *threadData,const char *name, int rows, int cols, unsigned int size);
    73 static void mat_writeMatVer4Matrix(simulation_result *self,DATA *data, threadData_t *threadData, const char *name, int rows, int cols, const void *, unsigned int size);
     85static void mat_writeMatVer4MatrixHeader(simulation_result *self,DATA *data, threadData_t *threadData,const char *name, int rows, int cols, MAT4_MATRIX_TYPE mat4_matrix_type);
     86static void mat_writeMatVer4Matrix(simulation_result *self,DATA *data, threadData_t *threadData, const char *name, int rows, int cols, const void *, MAT4_MATRIX_TYPE mat4_matrix_type);
    7487static void generateDataInfo(simulation_result *self,DATA *data, threadData_t *threadData,int* &dataInfo, int& rows, int& cols, int nVars, int nParams);
    7588static void generateData_1(DATA *data, threadData_t *threadData, double* &data_1, int& rows, int& cols, double tstart, double tstop);
    … …  
    90103  int sz = 1; /* start with one for the timeValue */
    91104
    92   if(self->cpuTime)
     105  if (self->cpuTime) {
    93106    sz++;
    94 
    95   if(omc_flag[FLAG_SOLVER_STEPS])
     107  }
     108  if (omc_flag[FLAG_SOLVER_STEPS]) {
    96109    sz++;
    97 
    98   for(int i = 0; i < modelData->nVariablesReal; i++)
    99     if(!modelData->realVarsData[i].filterOutput)
    100     {
     110  }
     111  for(int i = 0; i < modelData->nVariablesReal; i++) {
     112    if(!modelData->realVarsData[i].filterOutput) {
    101113       matData->r_indx_map[i] = sz;
    102114       sz++;
    103115    }
     116  }
    104117
    105118  /* put sensitivity analysis also to the result file */
    106   if (omc_flag[FLAG_IDAS])
    107   {
     119  if (omc_flag[FLAG_IDAS]) {
    108120    sz += (data->modelData->nSensitivityVars-data->modelData->nSensitivityParamVars);
    109121  }
    110122
    111   for(int i = 0; i < modelData->nVariablesInteger; i++)
    112     if(!modelData->integerVarsData[i].filterOutput)
    113     {
     123  for (int i = 0; i < modelData->nVariablesInteger; i++) {
     124    if(!modelData->integerVarsData[i].filterOutput) {
    114125       matData->i_indx_map[i] = sz;
    115126       sz++;
    116127    }
    117   for(int i = 0; i < modelData->nVariablesBoolean; i++)
    118     if(!modelData->booleanVarsData[i].filterOutput)
    119     {
     128  }
     129  for (int i = 0; i < modelData->nVariablesBoolean; i++) {
     130    if(!modelData->booleanVarsData[i].filterOutput) {
    120131       matData->b_indx_map[i] = sz;
    121132       sz++;
    122133    }
    123   for(int i = 0; i < modelData->nAliasReal; i++)
     134  }
     135  for(int i = 0; i < modelData->nAliasReal; i++) {
    124136    if(!modelData->realAlias[i].filterOutput) sz++;
    125   for(int i = 0; i < modelData->nAliasInteger; i++)
     137  }
     138  for(int i = 0; i < modelData->nAliasInteger; i++) {
    126139    if(!modelData->integerAlias[i].filterOutput) sz++;
     140  }
    127141  matData->negatedboolaliases = 0;
    128   for(int i = 0; i < modelData->nAliasBoolean; i++)
    129     if(!modelData->booleanAlias[i].filterOutput)
    130     {
    131        if(modelData->booleanAlias[i].negate)
    132           matData->negatedboolaliases++;
    133        sz++;
    134     }
     142  for(int i = 0; i < modelData->nAliasBoolean; i++) {
     143    if(!modelData->booleanAlias[i].filterOutput) {
     144      if(modelData->booleanAlias[i].negate) {
     145        matData->negatedboolaliases++;
     146      }
     147      sz++;
     148    }
     149  }
    135150  return sz;
    136151}
    … …  
    143158  int i, sz = 1;
    144159
    145   for (i = 0; i < modelData->nParametersReal; i++)
    146     if (!modelData->realParameterData[i].filterOutput)
    147     {
     160  for (i = 0; i < modelData->nParametersReal; i++) {
     161    if (!modelData->realParameterData[i].filterOutput) {
    148162      matData->r_indx_parammap[i] = sz;
    149163      sz ++;
    150164    }
    151 
    152   for (i = 0; i < modelData->nParametersInteger; i++)
    153     if(!modelData->integerParameterData[i].filterOutput)
    154     {
     165  }
     166
     167  for (i = 0; i < modelData->nParametersInteger; i++) {
     168    if(!modelData->integerParameterData[i].filterOutput) {
    155169      matData->i_indx_parammap[i] = sz;
    156170      sz ++;
    157171    }
    158 
    159   for (i = 0; i < modelData->nParametersBoolean; i++)
    160     if(!modelData->booleanParameterData[i].filterOutput)
    161     {
     172  }
     173
     174  for (i = 0; i < modelData->nParametersBoolean; i++) {
     175    if(!modelData->booleanParameterData[i].filterOutput) {
    162176      matData->b_indx_parammap[i] = sz;
    163177      sz ++;
    164178    }
     179  }
    165180
    166181  return sz - 1;
    … …  
    176191  names[curVar++] = &timeValName;
    177192
    178   if(self->cpuTime)
     193  if (self->cpuTime) {
    179194    names[curVar++] = &cpuTimeValName;
    180 
    181   if(omc_flag[FLAG_SOLVER_STEPS])
     195  }
     196
     197  if (omc_flag[FLAG_SOLVER_STEPS]) {
    182198    names[curVar++] = &solverStepsValName;
    183 
    184   for(int i = 0; i < modelData->nVariablesReal; i++) if(!modelData->realVarsData[i].filterOutput)
     199  }
     200
     201  for (int i = 0; i < modelData->nVariablesReal; i++) if(!modelData->realVarsData[i].filterOutput) {
    185202    names[curVar++] = &(modelData->realVarsData[i].info);
     203  }
    186204
    187205  /* put sensitivity analysis also to the result file */
    188   if (omc_flag[FLAG_IDAS])
    189   {
    190     for(int i = data->modelData->nSensitivityParamVars; i < data->modelData->nSensitivityVars; i++)
    191     {
     206  if (omc_flag[FLAG_IDAS]) {
     207    for(int i = data->modelData->nSensitivityParamVars; i < data->modelData->nSensitivityVars; i++) {
    192208      names[curVar++] = &(modelData->realSensitivityData[i].info);
    193209    }
    194210  }
    195   for(int i = 0; i < modelData->nVariablesInteger; i++) if(!modelData->integerVarsData[i].filterOutput)
     211  for(int i = 0; i < modelData->nVariablesInteger; i++) if(!modelData->integerVarsData[i].filterOutput) {
    196212    names[curVar++] = &(modelData->integerVarsData[i].info);
    197   for(int i = 0; i < modelData->nVariablesBoolean; i++) if(!modelData->booleanVarsData[i].filterOutput)
     213  }
     214  for(int i = 0; i < modelData->nVariablesBoolean; i++) if(!modelData->booleanVarsData[i].filterOutput) {
    198215    names[curVar++] = &(modelData->booleanVarsData[i].info);
    199   for(int i = 0; i < modelData->nAliasReal; i++) if(!modelData->realAlias[i].filterOutput)
     216  }
     217  for(int i = 0; i < modelData->nAliasReal; i++) if(!modelData->realAlias[i].filterOutput) {
    200218    names[curVar++] = &(modelData->realAlias[i].info);
    201   for(int i = 0; i < modelData->nAliasInteger; i++) if(!modelData->integerAlias[i].filterOutput)
     219  }
     220  for(int i = 0; i < modelData->nAliasInteger; i++) if(!modelData->integerAlias[i].filterOutput) {
    202221    names[curVar++] = &(modelData->integerAlias[i].info);
    203   for(int i = 0; i < modelData->nAliasBoolean; i++) if(!modelData->booleanAlias[i].filterOutput)
     222  }
     223  for(int i = 0; i < modelData->nAliasBoolean; i++) if(!modelData->booleanAlias[i].filterOutput) {
    204224    names[curVar++] = &(modelData->booleanAlias[i].info);
    205 
    206   for(int i = 0; i < modelData->nParametersReal; i++)
    207   {
    208     if (!modelData->realParameterData[i].filterOutput)
     225  }
     226
     227  for(int i = 0; i < modelData->nParametersReal; i++) {
     228    if (!modelData->realParameterData[i].filterOutput) {
    209229      names[curVar++] = &(modelData->realParameterData[i].info);
    210   }
    211   for(int i = 0; i < modelData->nParametersInteger; i++)
    212   {
    213     if (!modelData->integerParameterData[i].filterOutput)
     230    }
     231  }
     232  for(int i = 0; i < modelData->nParametersInteger; i++) {
     233    if (!modelData->integerParameterData[i].filterOutput) {
    214234      names[curVar++] = &(modelData->integerParameterData[i].info);
    215   }
    216   for(int i = 0; i < modelData->nParametersBoolean; i++)
    217   {
    218     if (!modelData->booleanParameterData[i].filterOutput)
     235    }
     236  }
     237  for(int i = 0; i < modelData->nParametersBoolean; i++) {
     238    if (!modelData->booleanParameterData[i].filterOutput) {
    219239      names[curVar++] = &(modelData->booleanParameterData[i].info);
     240    }
    220241  }
    221242
    … …  
    229250  int rows, cols;
    230251  double *doubleMatrix = NULL;
    231   try
    232   {
     252  try {
    233253    std::ofstream::pos_type remember = matData->fp.tellp();
    234254    matData->fp.seekp(matData->data1HdrPos);
    … …  
    236256    generateData_1(data, threadData, doubleMatrix, rows, cols, matData->startTime, matData->stopTime);
    237257    /*  write `data_1' matrix */
    238     mat_writeMatVer4Matrix(self,data, threadData,"data_1", cols, rows, doubleMatrix, sizeof(double));
     258    mat_writeMatVer4Matrix(self,data, threadData,"data_1", cols, rows, doubleMatrix, MAT4_DOUBLE_PRECISION_FULL_MATRIX);
    239259    free(doubleMatrix); doubleMatrix = NULL;
    240260    matData->fp.seekp(remember);
    241   }
    242   catch(...)
    243   {
     261  } catch(...) {
    244262    matData->fp.close();
    245263    free(doubleMatrix);
    … …  
    282300
    283301    /* write `AClass' matrix */
    284     mat_writeMatVer4Matrix(self,data, threadData,"Aclass", 4, 11, Aclass, sizeof(int8_t));
     302    mat_writeMatVer4Matrix(self,data, threadData,"Aclass", 4, 11, Aclass, MAT4_STRING_TEXT_MATRIX);
    285303    /* flatten variables' names */
    286304    flattenStrBuf(matData->numVars + matData->numParams, names, stringMatrix, rows, cols, false /* We cannot plot derivatives if we fix the names ... */, false);
    287305    /* write `name' matrix */
    288     mat_writeMatVer4Matrix(self,data,threadData,"name", rows, cols, stringMatrix, sizeof(int8_t));
     306    mat_writeMatVer4Matrix(self,data,threadData,"name", rows, cols, stringMatrix, MAT4_STRING_TEXT_MATRIX);
    289307    free(stringMatrix); stringMatrix = NULL;
    290308
    … …  
    292310    flattenStrBuf(matData->numVars + matData->numParams, names, stringMatrix, rows, cols, false, true);
    293311    /* write `description' matrix */
    294     mat_writeMatVer4Matrix(self,data,threadData,"description", rows, cols, stringMatrix, sizeof(int8_t));
     312    mat_writeMatVer4Matrix(self,data,threadData,"description", rows, cols, stringMatrix, MAT4_STRING_TEXT_MATRIX);
    295313    free(stringMatrix); stringMatrix = NULL;
    296314
    … …  
    298316    generateDataInfo(self, data, threadData, intMatrix, rows, cols, matData->numVars, matData->numParams);
    299317    /* write `dataInfo' matrix */
    300     mat_writeMatVer4Matrix(self, data, threadData, "dataInfo", cols, rows, intMatrix, sizeof(int32_t));
     318    mat_writeMatVer4Matrix(self, data, threadData, "dataInfo", cols, rows, intMatrix, MAT4_32BIT_INTEGER_FULL_MATRIX);
    301319
    302320    /* remember data1HdrPos */
    … …  
    307325    generateData_1(data, threadData, doubleMatrix, rows, cols, matData->startTime, matData->stopTime);
    308326    /*  write `data_1' matrix */
    309     mat_writeMatVer4Matrix(self,data,threadData,"data_1", cols, rows, doubleMatrix, sizeof(double));
     327    mat_writeMatVer4Matrix(self,data,threadData,"data_1", cols, rows, doubleMatrix, MAT4_DOUBLE_PRECISION_FULL_MATRIX);
    310328
    311329    /* remember data2HdrPos */
    312330    matData->data2HdrPos = matData->fp.tellp();
    313331    /* write `data_2' header */
    314     mat_writeMatVer4MatrixHeader(self,data,threadData,"data_2", matData->r_indx_map.size() + matData->i_indx_map.size() + matData->b_indx_map.size() + matData->negatedboolaliases + 1 /* add one more for timeValue*/ + self->cpuTime + /* add one more for solverSteps*/ + omc_flag[FLAG_SOLVER_STEPS] + nSensitivities, 0, sizeof(double));
     332    mat_writeMatVer4MatrixHeader(self,data,threadData,"data_2",
     333                                 matData->r_indx_map.size() + matData->i_indx_map.size() + matData->b_indx_map.size() + matData->negatedboolaliases + 1 /* add one more for timeValue*/ + self->cpuTime + /* add one more for solverSteps*/ + omc_flag[FLAG_SOLVER_STEPS] + nSensitivities, 0,
     334                                 omc_flag[FLAG_SINGLE_PRECISION] ? MAT4_SINGLE_PRECISION_FULL_MATRIX : MAT4_DOUBLE_PRECISION_FULL_MATRIX);
    315335
    316336    free(doubleMatrix);
    … …  
    320340    matData->fp.flush();
    321341
    322   }
    323   catch(...)
    324   {
     342  } catch(...) {
    325343    matData->fp.close();
    326344    free(names); names=NULL;
    … …  
    349367    {
    350368      matData->fp.seekp(matData->data2HdrPos);
    351       mat_writeMatVer4MatrixHeader(self,data,threadData,"data_2", matData->r_indx_map.size() + matData->i_indx_map.size() + matData->b_indx_map.size() + matData->negatedboolaliases + 1 /* add one more for timeValue*/ + self->cpuTime + /* add one more for solverSteps*/ + omc_flag[FLAG_SOLVER_STEPS] + nSensitivities, matData->ntimepoints, sizeof(double));
     369      mat_writeMatVer4MatrixHeader(self,data,threadData,"data_2", matData->r_indx_map.size() + matData->i_indx_map.size() + matData->b_indx_map.size() + matData->negatedboolaliases + 1 /* add one more for timeValue*/ + self->cpuTime + /* add one more for solverSteps*/ + omc_flag[FLAG_SOLVER_STEPS] + nSensitivities, matData->ntimepoints, omc_flag[FLAG_SINGLE_PRECISION] ? MAT4_SINGLE_PRECISION_FULL_MATRIX : MAT4_DOUBLE_PRECISION_FULL_MATRIX);
    352370      matData->fp.close();
    353371    }
    … …  
    362380}
    363381
     382static inline void writeSingleRealOutput(mat_data *matData, double v)
     383{
     384  if (omc_flag[FLAG_SINGLE_PRECISION]) {
     385    float datPoint = v;
     386    matData->fp.write((char*)&datPoint, sizeof(float));
     387  } else {
     388    matData->fp.write((char*)&v, sizeof(double));
     389  }
     390}
     391
    364392void mat4_emit(simulation_result *self,DATA *data, threadData_t *threadData)
    365393{
    … …  
    375403     although ofstream does have some buffering, but it is not enough and
    376404     not for this purpose */
    377   matData->fp.write((char*)&(data->localData[0]->timeValue), sizeof(double));
    378 
    379   if(self->cpuTime)
    380     matData->fp.write((char*)&cpuTimeValue, sizeof(double));
    381 
    382   if(omc_flag[FLAG_SOLVER_STEPS])
    383     matData->fp.write((char*)&(data->simulationInfo->solverSteps), sizeof(double));
    384 
    385   for(int i = 0; i < data->modelData->nVariablesReal; i++) if(!data->modelData->realVarsData[i].filterOutput)
    386     matData->fp.write((char*)&(data->localData[0]->realVars[i]),sizeof(double));
     405  writeSingleRealOutput(matData, data->localData[0]->timeValue);
     406
     407  if(self->cpuTime) {
     408    writeSingleRealOutput(matData, cpuTimeValue);
     409  }
     410
     411  if(omc_flag[FLAG_SOLVER_STEPS]) {
     412    writeSingleRealOutput(matData, data->simulationInfo->solverSteps);
     413  }
     414
     415  for(int i = 0; i < data->modelData->nVariablesReal; i++) if(!data->modelData->realVarsData[i].filterOutput) {
     416    writeSingleRealOutput(matData, data->localData[0]->realVars[i]);
     417  }
    387418
    388419  /* put parameter sensitivity analysis also to the result file */
    389   if (omc_flag[FLAG_IDAS])
    390   {
    391     for(int i = 0; i < data->modelData->nSensitivityVars-data->modelData->nSensitivityParamVars; i++)
    392       matData->fp.write((char*)&(data->simulationInfo->sensitivityMatrix[i]),sizeof(double));
    393   }
    394   for(int i = 0; i < data->modelData->nVariablesInteger; i++) if(!data->modelData->integerVarsData[i].filterOutput)
    395     {
    396       datPoint = (double) data->localData[0]->integerVars[i];
    397       matData->fp.write((char*)&datPoint,sizeof(double));
    398     }
    399   for(int i = 0; i < data->modelData->nVariablesBoolean; i++) if(!data->modelData->booleanVarsData[i].filterOutput)
    400     {
    401       datPoint = (double) data->localData[0]->booleanVars[i];
    402       matData->fp.write((char*)&datPoint,sizeof(double));
    403     }
    404   for(int i = 0; i < data->modelData->nAliasBoolean; i++) if(!data->modelData->booleanAlias[i].filterOutput)
    405     {
    406       if(data->modelData->booleanAlias[i].negate)
    407       {
    408         datPoint = (double) (data->localData[0]->booleanVars[data->modelData->booleanAlias[i].nameID]==1?0:1);
    409         matData->fp.write((char*)&datPoint,sizeof(double));
    410       }
    411     }
     420  if (omc_flag[FLAG_IDAS]) {
     421    for(int i = 0; i < data->modelData->nSensitivityVars-data->modelData->nSensitivityParamVars; i++) {
     422      writeSingleRealOutput(matData, data->simulationInfo->sensitivityMatrix[i]);
     423    }
     424  }
     425  for (int i = 0; i < data->modelData->nVariablesInteger; i++) {
     426    if(!data->modelData->integerVarsData[i].filterOutput) {
     427      writeSingleRealOutput(matData, (double) data->localData[0]->integerVars[i]);
     428    }
     429  }
     430  for (int i = 0; i < data->modelData->nVariablesBoolean; i++) {
     431    if(!data->modelData->booleanVarsData[i].filterOutput) {
     432      writeSingleRealOutput(matData, (double) data->localData[0]->booleanVars[i]);
     433    }
     434  }
     435  for (int i = 0; i < data->modelData->nAliasBoolean; i++) {
     436    if(!data->modelData->booleanAlias[i].filterOutput) {
     437      if(data->modelData->booleanAlias[i].negate) {
     438        writeSingleRealOutput(matData, (double) (data->localData[0]->booleanVars[data->modelData->booleanAlias[i].nameID]==1?0:1));
     439      }
     440    }
     441  }
    412442  if (!matData->fp) {
    413443    throwStreamPrint(threadData, "Error while writing file %s",self->filename);
    … …  
    436466}
    437467
    438 long flattenStrBuf(int dims, const struct VAR_INFO** src, char* &dest, int& longest, int& nstrings, bool fixNames, bool useComment)
     468static long flattenStrBuf(int dims, const struct VAR_INFO** src, char* &dest, int& longest, int& nstrings, bool fixNames, bool useComment)
    439469{
    440470  int i,len;
    … …  
    469499
    470500// writes MAT-file matrix header to file
    471 void mat_writeMatVer4MatrixHeader(simulation_result *self, DATA *data, threadData_t *threadData, const char *name, int rows, int cols, unsigned int size)
     501static void mat_writeMatVer4MatrixHeader(simulation_result *self, DATA *data, threadData_t *threadData, const char *name, int rows, int cols, MAT4_MATRIX_TYPE mat4_matrix_type)
    472502{
    473503  mat_data *matData = (mat_data*) self->storage;
    … …  
    481511  const int endian_test = 1;
    482512  MHeader_t hdr;
    483 
    484   int type = 0;
    485   if(size == 1 /* char */)
    486     type = 51;
    487   if(size == 4 /* int32 */)
    488     type = 20;
     513  int size = MAT4_SIZE_OF_MATRIX_TYPE[mat4_matrix_type];
     514  int type = MAT4_MOPT_OF_MATRIX_TYPE[mat4_matrix_type];
    489515
    490516  /* create matrix header structure */
    … …  
    505531}
    506532
    507 void mat_writeMatVer4Matrix(simulation_result *self, DATA *data, threadData_t *threadData, const char *name, int rows, int cols, const void *matrixData, unsigned int size)
     533static void mat_writeMatVer4Matrix(simulation_result *self, DATA *data, threadData_t *threadData, const char *name, int rows, int cols, const void *matrixData, MAT4_MATRIX_TYPE mat4_matrix_type)
    508534{
    509535  mat_data *matData = (mat_data*) self->storage;
    510   mat_writeMatVer4MatrixHeader(self, data, threadData, name, rows, cols, size);
     536  mat_writeMatVer4MatrixHeader(self, data, threadData, name, rows, cols, mat4_matrix_type);
    511537
    512538  /* write data */
    513   matData->fp.write((const char*)matrixData, (size)*rows*cols);
     539  matData->fp.write((const char*)matrixData, MAT4_SIZE_OF_MATRIX_TYPE[mat4_matrix_type]*rows*cols);
    514540  if(!matData->fp) {
    515541    throwStreamPrint(threadData, "Cannot write to file %s",self->filename);
    … …  
    518544
    519545
    520 void generateDataInfo(simulation_result *self, DATA *data, threadData_t *threadData, int32_t* &dataInfo, int& rows, int& cols, int nVars, int nParams)
     546static void generateDataInfo(simulation_result *self, DATA *data, threadData_t *threadData, int32_t* &dataInfo, int& rows, int& cols, int nVars, int nParams)
    521547{
    522548  mat_data *matData = (mat_data*) self->storage;
    … …  
    682708}
    683709
    684 void generateData_1(DATA *data, threadData_t *threadData, double* &data_1, int& rows, int& cols, double tstart, double tstop)
     710static void generateData_1(DATA *data, threadData_t *threadData, double* &data_1, int& rows, int& cols, double tstart, double tstop)
    685711{
    686712  const SIMULATION_INFO *sInfo = data->simulationInfo;

  • SimulationRuntime/c/util/simulation_options.c

    ra766c29 raeb9725  
    125125  /* FLAG_RT */                           "rt",
    126126  /* FLAG_S */                            "s",
     127  /* FLAG_SINGLE_PRECISION */             "single",
    127128  /* FLAG_SOLVER_STEPS */                 "steps",
    128129  /* FLAG_STEADY_STATE */                 "steadyState",
    … …  
    228229  /* FLAG_RT */                           "value specifies the scaling factor for real-time synchronization (0 disables)",
    229230  /* FLAG_S */                            "value specifies the integration method",
     231  /* FLAG_SINGLE */                       "output in single precision",
    230232  /* FLAG_SOLVER_STEPS */                 "dumps the number of integration steps into the result file",
    231233  /* FLAG_STEADY_STATE */                 "aborts if steady state is reached",
    … …  
    485487  /* FLAG_S */
    486488  "  Value specifies the integration method.",
     489  /* FLAG_SINGLE */
     490  "  Output results in single precision (mat-format only).",
    487491  /* FLAG_SOLVER_STEPS */
    488492  "  dumps the number of integration steps into the result file",
    … …  
    593597  /* FLAG_RT */                           FLAG_TYPE_OPTION,
    594598  /* FLAG_S */                            FLAG_TYPE_OPTION,
     599  /* FLAG_SINGLE */                       FLAG_TYPE_FLAG,
    595600  /* FLAG_SOLVER_STEPS */                 FLAG_TYPE_FLAG,
    596601  /* FLAG_STEADY_STATE */                 FLAG_TYPE_FLAG,

  • SimulationRuntime/c/util/simulation_options.h

    ra766c29 raeb9725  
    133133  FLAG_RT,
    134134  FLAG_S,
     135  FLAG_SINGLE_PRECISION,
    135136  FLAG_SOLVER_STEPS,
    136137  FLAG_STEADY_STATE,
Note: See TracChangeset for help on using the changeset viewer.