Do not store time in the data_1 matrix

Also changed the number of rows in the data_1 matrix to 1 instead of 2.
Previously, startTime/stopTtime was stored in the data_1 matrix, but
this is not really necessary.

Belonging to [master]:
  - #1920
  - OpenModelica/OpenModelica-testsuite#749

Author: sjoelund

SimulationRuntime/c/simulation/results/simulation_result_mat.cpp

@@ -256,7 +256,10 @@ void mat4_writeParameterData(simulation_result *self,DATA *data, threadData_t *t
     generateData_1(data, threadData, doubleMatrix, rows, cols, matData->startTime, matData->stopTime);
     /*  write `data_1' matrix */
     mat_writeMatVer4Matrix(self,data, threadData,"data_1", cols, rows, doubleMatrix, MAT4_DOUBLE_PRECISION_FULL_MATRIX);
-    free(doubleMatrix); doubleMatrix = NULL;
+    if (doubleMatrix) {
+      free(doubleMatrix);
+      doubleMatrix = NULL;
+    }
     matData->fp.seekp(remember);
   } catch(...) {
     matData->fp.close();
@@ -333,17 +336,22 @@ void mat4_init(simulation_result *self,DATA *data, threadData_t *threadData)
                                  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,
                                  omc_flag[FLAG_SINGLE_PRECISION] ? MAT4_SINGLE_PRECISION_FULL_MATRIX : MAT4_DOUBLE_PRECISION_FULL_MATRIX);
 
-    free(doubleMatrix);
+    if (doubleMatrix) {
+      free(doubleMatrix);
+      doubleMatrix = NULL;
+    }
     free(intMatrix);
-    doubleMatrix = NULL;
     intMatrix = NULL;
     matData->fp.flush();
 
   } catch(...) {
     matData->fp.close();
     free(names); names=NULL;
     free(stringMatrix);
-    free(doubleMatrix);
+    if (doubleMatrix) {
+      free(doubleMatrix);
+      doubleMatrix = NULL;
+    }
     free(intMatrix);
     rt_accumulate(SIM_TIMER_OUTPUT);
     throwStreamPrint(threadData, "Error while writing mat file %s",self->filename);
@@ -558,7 +566,6 @@ static void generateDataInfo(simulation_result *self, DATA *data, threadData_t *
   /* assign rows & cols */
   rows = nVars + nParams;
   cols = 4;
-
   dataInfo = (int*) calloc(rows*cols,sizeof(int));
   assertStreamPrint(threadData, 0!=dataInfo,"Cannot alloc memory");
   /* continuous and discrete variables, including time */
@@ -593,7 +600,7 @@ static void generateDataInfo(simulation_result *self, DATA *data, threadData_t *
         if(it != matData->r_indx_parammap.end())
         {
           table = 1;
-          aliascol = it->second+1;
+          aliascol = it->second;
         }
       } else if(mdl_data->realAlias[i].aliasType == 2) /* time */
       {
@@ -612,7 +619,7 @@ static void generateDataInfo(simulation_result *self, DATA *data, threadData_t *
         /* row 3 - linear interpolation == 0 */
         dataInfo[ccol+2] = 0;
         /* row 4 - not defined outside of the defined time range == -1 */
-        dataInfo[ccol+3] = -1;
+        dataInfo[ccol+3] = mdl_data->realAlias[i].aliasType == 1 ? 0 : -1;
         ccol += 4;
       }
     }
@@ -624,24 +631,28 @@ static void generateDataInfo(simulation_result *self, DATA *data, threadData_t *
       if(mdl_data->integerAlias[i].aliasType == 0) /* variable */
       {
         it = matData->i_indx_map.find(mdl_data->integerAlias[i].nameID);
-        if(it != matData->i_indx_map.end())
+        if(it != matData->i_indx_map.end()) {
           table = 2;
+        }
+        aliascol = it->second+1;
       }
       else if(mdl_data->integerAlias[i].aliasType == 1) /* parameter */
       {
         it = matData->i_indx_parammap.find(mdl_data->integerAlias[i].nameID);
-        if(it != matData->i_indx_parammap.end())
+        if(it != matData->i_indx_parammap.end()) {
           table = 1;
+        }
+        aliascol = it->second;
       }
       if(table)
       {
         /* row 1 - which table */
         dataInfo[ccol] = table;
         /* row 2 - index of var in table */
         if(mdl_data->integerAlias[i].negate)
-          dataInfo[ccol+1] = -(it->second+1);
+          dataInfo[ccol+1] = -aliascol;
         else
-          dataInfo[ccol+1] = it->second+1;
+          dataInfo[ccol+1] = aliascol;
         /* row 3 - linear interpolation == 0 */
         dataInfo[ccol+2] = 0;
         /* row 4 - not defined outside of the defined time range == -1 */
@@ -662,28 +673,31 @@ static void generateDataInfo(simulation_result *self, DATA *data, threadData_t *
         if(mdl_data->booleanAlias[i].aliasType == 0) /* variable */
         {
           it = matData->b_indx_map.find(mdl_data->booleanAlias[i].nameID);
-          if(it != matData->b_indx_map.end())
+          if(it != matData->b_indx_map.end()) {
             table = 2;
+          }
+          aliascol = it->second+1;
         }
         else if(mdl_data->booleanAlias[i].aliasType == 1) /* parameter */
         {
           it = matData->b_indx_parammap.find(mdl_data->booleanAlias[i].nameID);
-          if(it != matData->b_indx_parammap.end())
+          if(it != matData->b_indx_parammap.end()) {
             table = 1;
+          }
+          aliascol = it->second;
         }
       }
       if(table)
       {
         /* row 1 - which table */
         dataInfo[ccol] = table;
         /* row 2 - index of var in table */
-        if(mdl_data->booleanAlias[i].negate)
-        {
+        if(mdl_data->booleanAlias[i].negate) {
           dataInfo[ccol+1] = indx;
           indx++;
+        } else {
+          dataInfo[ccol+1] = aliascol;
         }
-        else
-          dataInfo[ccol+1] = it->second+1;
         /* row 3 - linear interpolation == 0 */
         dataInfo[ccol+2] = 0;
         /* row 4 - not defined outside of the defined time range == -1 */
@@ -696,13 +710,12 @@ static void generateDataInfo(simulation_result *self, DATA *data, threadData_t *
   for(size_t i = 0; i < (size_t)nParams; ++i) {
       /* col 1 - which table */
       dataInfo[ccol+4*i] = 1;
-      /* col 2 - index of var in the table (first parameter has index 2) */
-      dataInfo[ccol+4*i+1] = i+2;
+      /* col 2 - index of var in the table (first parameter has index 1) */
+      dataInfo[ccol+4*i+1] = i+1;
       /* col 3 (== 0 <- interpolation doesn't matter here) */
       dataInfo[ccol+4*i+2] = 0;
       /* col 4 - keep first/last value outside of time range */
       dataInfo[ccol+4*i+3] = 0;
-
   }
   /* ccol += mdl_data->nParameters*4; */
 }
@@ -712,47 +725,47 @@ static void generateData_1(DATA *data, threadData_t *threadData, double* &data_1
   const SIMULATION_INFO *sInfo = data->simulationInfo;
   const MODEL_DATA      *mData = data->modelData;
 
-  int offset = 1;
+  int offset = 0;
   long i = 0;
 
   /* calculate number of rows and columns */
-  rows = 2;
-  cols = 1 + mData->nParametersReal +
-             mData->nParametersInteger +
-             mData->nParametersBoolean;
+  cols = mData->nParametersReal +
+         mData->nParametersInteger +
+         mData->nParametersBoolean;
+  if (cols) {
+    rows = 1;
+  } else {
+    rows = 0;
+  }
 
   /* allocate data buffer */
-  data_1 = (double*)calloc(rows*cols, sizeof(double));
-  assertStreamPrint(threadData, 0!=data_1, "Malloc failed");
-  data_1[0] = tstart;     /* start time */
-  data_1[cols] = tstop;   /* stop time */
+  if (rows) {
+    data_1 = (double*)calloc(rows*cols, sizeof(double));
+    assertStreamPrint(threadData, 0!=data_1, "Malloc failed");
+  } else {
+    data_1 = NULL;
+  }
 
   /* double variables */
-  for(i = 0; i < mData->nParametersReal; ++i)
-  {
+  for(i = 0; i < mData->nParametersReal; ++i) {
     if (!mData->realParameterData[i].filterOutput) {
       data_1[offset] = sInfo->realParameter[i];
-      data_1[offset+cols] = sInfo->realParameter[i];
       offset ++;
     }
   }
 
   /* integer variables */
-  for(i = 0; i < mData->nParametersInteger; ++i)
-  {
+  for(i = 0; i < mData->nParametersInteger; ++i) {
     if (!mData->integerParameterData[i].filterOutput) {
       data_1[offset] = (double)sInfo->integerParameter[i];
-      data_1[offset+cols] = (double)sInfo->integerParameter[i];
       offset ++;
     }
   }
 
   /* bool variables */
-  for(i = 0; i < mData->nParametersBoolean; ++i)
-  {
+  for(i = 0; i < mData->nParametersBoolean; ++i) {
     if (!mData->booleanParameterData[i].filterOutput) {
       data_1[offset] = (double)sInfo->booleanParameter[i];
-      data_1[offset+cols] = (double)sInfo->booleanParameter[i];
       offset ++;
     }
   }

SimulationRuntime/c/simulation/solver/initialization/initialization.c

@@ -413,13 +413,10 @@ int importStartValues(DATA *data, threadData_t *threadData, const char *pInitFil
   }
 
   pError = omc_new_matlab4_reader(pInitFile, &reader);
-  if(pError)
-  {
+  if(pError) {
     throwStreamPrint(threadData, "unable to read input-file <%s> [%s]", pInitFile, pError);
     return 1;
-  }
-  else
-  {
+  } else {
     infoStreamPrint(LOG_INIT, 0, "import real variables");
     for(i=0; i<mData->nVariablesReal; ++i) {
       pVar = omc_matlab4_find_var(&reader, mData->realVarsData[i].info.name);
@@ -429,7 +426,6 @@ int importStartValues(DATA *data, threadData_t *threadData, const char *pInitFil
         pVar = omc_matlab4_find_var(&reader, newVarname);
         free(newVarname);
       }
-
       if(pVar) {
         omc_matlab4_val(&(mData->realVarsData[i].attribute.start), &reader, pVar, initTime);
         infoStreamPrint(LOG_INIT, 0, "| %s(start=%g)", mData->realVarsData[i].info.name, mData->realVarsData[i].attribute.start);

SimulationRuntime/c/util/read_matlab4.c

@@ -195,6 +195,9 @@ static int read_int32(int type, size_t n, FILE *file, int32_t *val)
 static int read_double(int type, size_t n, FILE *file, double *val)
 {
   int p = (type%100)/10;
+  if (n==0) {
+    return 0;
+  }
   if (p == 0) { /* Double */
     return fread(val,n*sizeof(double),1,file) != 1;
   } else if (p == 1) { /* float */
@@ -227,6 +230,7 @@ const char* omc_new_matlab4_reader(const char *filename, ModelicaMatReader *read
   if(!reader->file) return strerror(errno);
   reader->fileName = strdup(filename);
   reader->readAll = 0;
+  reader->stopTime = NAN;
   for(i=0; i<nMatrix;i++) {
     MHeader_t hdr;
     int nr = fread(&hdr,sizeof(MHeader_t),1,reader->file);
@@ -388,24 +392,24 @@ const char* omc_new_matlab4_reader(const char *filename, ModelicaMatReader *read
     case 4: { /* "data_1" */
       unsigned int k;
       if(binTrans==1) {
-        if(hdr.mrows == 0) return "data_1 matrix does not contain at least 1 variable";
-        if(hdr.ncols != 2 && hdr.ncols != 1) return "data_1 matrix does not have 1 or 2 cols";
+        if(hdr.mrows != 0 || hdr.ncols != 0) {
+          if(hdr.ncols != 2 && hdr.ncols != 1) return "data_1 matrix does not have 1 or 2 cols (or 0 rows/columns)";
+        }
         reader->nparam = hdr.mrows;
-        reader->params = (double*) malloc(hdr.mrows*hdr.ncols*sizeof(double));
+        reader->params = reader->nparam > 0 ? (double*) malloc(hdr.mrows*hdr.ncols*sizeof(double)) : NULL;
         if (read_double(hdr.type, hdr.mrows*hdr.ncols, reader->file, reader->params)) {
           return "Corrupt header: data_1 matrix";
         }
-       /* fprintf(stderr, "    startTime = %.6g\n", reader->params[0]);
-        * fprintf(stderr, "    stopTime = %.6g\n", reader->params[1]); */
       }
       if(binTrans==0) {
         unsigned int j;
-        if(hdr.ncols == 0) return "data_1 matrix does not contain at least 1 variable";
-        if(hdr.mrows != 2 && hdr.mrows != 1) return "data_1 matrix does not have 1 or 2 rows";
+        if(hdr.mrows != 0 || hdr.ncols != 0) {
+          if(hdr.mrows != 2 && hdr.mrows != 1) return "data_1 matrix does not have 1 or 2 rows (or 0 rows/columns)";
+        }
         reader->nparam = hdr.ncols;
         double *tmp=NULL;
-        tmp = (double*) malloc(hdr.mrows*hdr.ncols*sizeof(double));
-        reader->params = (double*) malloc(hdr.mrows*hdr.ncols*sizeof(double));
+        tmp = reader->nparam > 0 ? (double*) malloc(hdr.mrows*hdr.ncols*sizeof(double)) : NULL;
+        reader->params = reader->nparam > 0 ? (double*) malloc(hdr.mrows*hdr.ncols*sizeof(double)) : NULL;
         if (read_double(hdr.type, hdr.mrows*hdr.ncols, reader->file, tmp)) {
           return "Corrupt header: data_1 matrix";
         }
@@ -414,10 +418,9 @@ const char* omc_new_matlab4_reader(const char *filename, ModelicaMatReader *read
             reader->params[k*hdr.ncols+j] = tmp[k +j*hdr.mrows];
           }
         }
-        free(tmp);
-      }
-      for(k=1; k<reader->nparam; k++) {
-        if(hdr.mrows == 2 && reader->params[k] != reader->params[k+reader->nparam]) return "data_1 matrix contained parameter that changed between start and stop-time";
+        if (tmp) {
+          free(tmp);
+        }
       }
       break;
     }
@@ -769,14 +772,30 @@ void find_closest_points(double key, double *vec, int nelem, int *index1, double
   *weight2 = 1.0 - *weight1;
 }
 
+static void read_start_stop_time(ModelicaMatReader *reader)
+{
+  double *d = omc_matlab4_read_vals(reader, 1);
+  if (d==NULL) {
+    return;
+  }
+  reader->startTime = d[0];
+  reader->stopTime = d[reader->nrows-1];
+}
+
 double omc_matlab4_startTime(ModelicaMatReader *reader)
 {
-  return reader->params[0];
+  if (reader->startTime != reader->startTime /* NaN */) {
+    read_start_stop_time(reader);
+  }
+  return reader->startTime;
 }
 
 double omc_matlab4_stopTime(ModelicaMatReader *reader)
 {
-  return reader->params[reader->nparam];
+  if (reader->stopTime != reader->stopTime /* NaN */) {
+    read_start_stop_time(reader);
+  }
+  return reader->stopTime;
 }
 
 /* Returns 0 on success */
@@ -790,9 +809,18 @@ int omc_matlab4_val(double *res, ModelicaMatReader *reader, ModelicaMatVariable_
   } else {
     double w1,w2,y1,y2;
     int i1,i2;
-    if(time > omc_matlab4_stopTime(reader)) return 1;
-    if(time < omc_matlab4_startTime(reader)) return 1;
-    if(!omc_matlab4_read_vals(reader,1)) return 1;
+    if(time > omc_matlab4_stopTime(reader)) {
+      *res = NAN;
+      return 1;
+    }
+    if(time < omc_matlab4_startTime(reader)) {
+      *res = NAN;
+      return 1;
+    }
+    if(!omc_matlab4_read_vals(reader,1)) {
+      *res = NAN;
+      return 1;
+    }
     find_closest_points(time, reader->vars[0], reader->nrows, &i1, &w1, &i2, &w2);
     if(i2 == -1) {
       return (int)omc_matlab4_read_single_val(res,reader,var->index,i1);

SimulationRuntime/c/util/read_matlab4.h

@@ -48,7 +48,8 @@ typedef struct {
   uint32_t nall;
   ModelicaMatVariable_t *allInfo; /* Sorted array of variables and their associated information */
   uint32_t nparam;
-  double *params; /* This has size 2*nparam; the first parameter has row0=startTime,row1=stopTime. Other variables are stored as row0=row1 */
+  double startTime, stopTime;
+  double *params; /* This has size nparam */
   uint32_t nvar,nrows;
   size_t var_offset; /* This is the offset in the file */
   int readAll; /* Read all variables already */
@@ -88,8 +89,8 @@ int omc_matlab4_read_vars_val(double *res, ModelicaMatReader *reader, ModelicaMa
 void omc_matlab4_print_all_vars(FILE *stream, ModelicaMatReader *reader);
 
 double omc_matlab4_startTime(ModelicaMatReader *reader);
-
 double omc_matlab4_stopTime(ModelicaMatReader *reader);
+
 void matrix_transpose(double *m, int w, int h);
 void matrix_transpose_uint32(uint32_t *m, int w, int h);
 int omc_matlab4_read_all_vals(ModelicaMatReader *reader);