static void fmtEmitStep(DATA* data, threadData_t *threadData, MEASURE_TIME* mt, int didEventStep)
{
if(mt->fmtReal)
{
int i, flag=1;
double tmpdbl;
unsigned int tmpint;
int total = data->modelData->modelDataXml.nFunctions + data->modelData->modelDataXml.nProfileBlocks;
rt_tick(SIM_TIMER_OVERHEAD);
rt_accumulate(SIM_TIMER_STEP);
/* Disable time measurements if we have trouble writing to the file... */
flag = flag && 1 == fwrite(&mt->stepNo, sizeof(unsigned int), 1, mt->fmtInt);
mt->stepNo++;
flag = flag && 1 == fwrite(&(data->localData[0]->timeValue), sizeof(double), 1, mt->fmtReal);
tmpdbl = rt_accumulated(SIM_TIMER_STEP);
flag = flag && 1 == fwrite(&tmpdbl, sizeof(double), 1, mt->fmtReal);
flag = flag && total == fwrite(rt_ncall_arr(SIM_TIMER_FIRST_FUNCTION), sizeof(uint32_t), total, mt->fmtInt);
for(i=0; i<data->modelData->modelDataXml.nFunctions + data->modelData->modelDataXml.nProfileBlocks; i++) {
tmpdbl = rt_accumulated(i + SIM_TIMER_FIRST_FUNCTION);
flag = flag && 1 == fwrite(&tmpdbl, sizeof(double), 1, mt->fmtReal);
}
rt_accumulate(SIM_TIMER_OVERHEAD);
if(!flag)
{
warningStreamPrint(LOG_SOLVER, 0, "Disabled time measurements because the output file could not be generated: %s", strerror(errno));
fclose(mt->fmtInt);
fclose(mt->fmtReal);
mt->fmtInt = NULL;
mt->fmtReal = NULL;
}
}
/* prevent emit if noEventEmit flag is used, if it's an event */
if ((omc_flag[FLAG_NOEVENTEMIT] && didEventStep == 0) || !omc_flag[FLAG_NOEVENTEMIT]) {
sim_result.emit(&sim_result, data, threadData);
}
#if !defined(OMC_MINIMAL_RUNTIME)
embedded_server_update(data->embeddedServerState, data->localData[0]->timeValue);
if (data->real_time_sync.enabled) {
double time = data->localData[0]->timeValue;
int64_t res = rt_ext_tp_sync_nanosec(&data->real_time_sync.clock, (uint64_t) (data->real_time_sync.scaling*(time-data->real_time_sync.time)*1e9));
int64_t maxLateNano = data->simulationInfo->stepSize*1e9*0.1*data->real_time_sync.scaling /* Maximum late time: 10% of step size */;
if (res > maxLateNano) {
int t=0,tMaxLate=0;
const char *unit = prettyPrintNanoSec(res, &t);
const char *unit2 = prettyPrintNanoSec(maxLateNano, &tMaxLate);
errorStreamPrint(LOG_RT, 0, "Missed deadline at time %g; delta was %d %s (maxLate=%d %s)", time, t, unit, tMaxLate, unit2);
}
if (res > data->real_time_sync.maxLate) {
data->real_time_sync.maxLate = res;
}
}
printAllVarsDebug(data, 0, LOG_DEBUG); /* ??? */
#endif
}
void csv_emit(simulation_result *self, DATA *data)
{
FILE *fout = (FILE*) self->storage;
const char* format = "%.16g,";
const char* formatint = "%i,";
const char* formatbool = "%i,";
const char* formatstring = "\"%s\",";
int i;
modelica_real value = 0;
double cpuTimeValue = 0;
rt_tick(SIM_TIMER_OUTPUT);
rt_accumulate(SIM_TIMER_TOTAL);
cpuTimeValue = rt_accumulated(SIM_TIMER_TOTAL);
rt_tick(SIM_TIMER_TOTAL);
fprintf(fout, format, data->localData[0]->timeValue);
if(self->cpuTime)
fprintf(fout, format, cpuTimeValue);
for(i = 0; i < data->modelData.nVariablesReal; i++) if(!data->modelData.realVarsData[i].filterOutput)
fprintf(fout, format, (data->localData[0])->realVars[i]);
for(i = 0; i < data->modelData.nVariablesInteger; i++) if(!data->modelData.integerVarsData[i].filterOutput)
fprintf(fout, formatint, (data->localData[0])->integerVars[i]);
for(i = 0; i < data->modelData.nVariablesBoolean; i++) if(!data->modelData.booleanVarsData[i].filterOutput)
fprintf(fout, formatbool, (data->localData[0])->booleanVars[i]);
for(i = 0; i < data->modelData.nVariablesString; i++) if(!data->modelData.stringVarsData[i].filterOutput)
fprintf(fout, formatstring, (data->localData[0])->stringVars[i]);
for(i = 0; i < data->modelData.nAliasReal; i++) if(!data->modelData.realAlias[i].filterOutput) {
if(data->modelData.realAlias[i].aliasType == 2)
value = (data->localData[0])->timeValue;
else
value = (data->localData[0])->realVars[data->modelData.realAlias[i].nameID];
if(data->modelData.realAlias[i].negate)
fprintf(fout, format, -value);
else
fprintf(fout, format, value);
}
for(i = 0; i < data->modelData.nAliasInteger; i++) if(!data->modelData.integerAlias[i].filterOutput) {
if(data->modelData.integerAlias[i].negate)
fprintf(fout, formatint, -(data->localData[0])->integerVars[data->modelData.integerAlias[i].nameID]);
else
fprintf(fout, formatint, (data->localData[0])->integerVars[data->modelData.integerAlias[i].nameID]);
}
for(i = 0; i < data->modelData.nAliasBoolean; i++) if(!data->modelData.booleanAlias[i].filterOutput) {
if(data->modelData.booleanAlias[i].negate)
fprintf(fout, formatbool, (data->localData[0])->booleanVars[data->modelData.booleanAlias[i].nameID]==1?0:1);
else
fprintf(fout, formatbool, (data->localData[0])->booleanVars[data->modelData.booleanAlias[i].nameID]);
}
for(i = 0; i < data->modelData.nAliasString; i++) if(!data->modelData.stringAlias[i].filterOutput) {
/* there would no negation of a string happen */
fprintf(fout, formatstring, (data->localData[0])->stringVars[data->modelData.stringAlias[i].nameID]);
}
fprintf(fout, "\n");
rt_accumulate(SIM_TIMER_OUTPUT);
}
void omc_csv_free(simulation_result *self, DATA *data)
{
FILE *fout = (FILE*) self->storage;
rt_tick(SIM_TIMER_OUTPUT);
fclose(fout);
rt_accumulate(SIM_TIMER_OUTPUT);
}
static int simulationUpdate(DATA* data, threadData_t *threadData, SOLVER_INFO* solverInfo)
{
prefixedName_updateContinuousSystem(data, threadData);
if (solverInfo->solverMethod == S_SYM_IMP_EULER) data->callback->symEulerUpdate(data, solverInfo->solverStepSize);
saveZeroCrossings(data, threadData);
messageClose(LOG_SOLVER);
/***** Event handling *****/
if (measure_time_flag) rt_tick(SIM_TIMER_EVENT);
int syncRet = handleTimers(data, threadData, solverInfo);
int syncRet1;
do
{
int eventType = checkEvents(data, threadData, solverInfo->eventLst, &(solverInfo->currentTime), solverInfo);
if(eventType > 0 || syncRet == 2) /* event */
{
threadData->currentErrorStage = ERROR_EVENTHANDLING;
infoStreamPrint(LOG_EVENTS, 1, "%s event at time=%.12g", eventType == 1 ? "time" : "state", solverInfo->currentTime);
/* prevent emit if noEventEmit flag is used */
if (!(omc_flag[FLAG_NOEVENTEMIT])) /* output left limit */
sim_result.emit(&sim_result, data, threadData);
handleEvents(data, threadData, solverInfo->eventLst, &(solverInfo->currentTime), solverInfo);
messageClose(LOG_EVENTS);
threadData->currentErrorStage = ERROR_SIMULATION;
solverInfo->didEventStep = 1;
overwriteOldSimulationData(data);
}
else /* no event */
{
solverInfo->laststep = solverInfo->currentTime;
solverInfo->didEventStep = 0;
}
if (measure_time_flag) rt_accumulate(SIM_TIMER_EVENT);
/***** End event handling *****/
/***** check state selection *****/
if (stateSelection(data, threadData, 1, 1))
{
/* if new set is calculated reinit the solver */
solverInfo->didEventStep = 1;
overwriteOldSimulationData(data);
}
/* Check for warning of variables out of range assert(min<x || x>xmax, ...)*/
data->callback->checkForAsserts(data, threadData);
storePreValues(data);
storeOldValues(data);
syncRet1 = handleTimers(data, threadData, solverInfo);
syncRet = syncRet1 == 0 ? syncRet : syncRet1;
} while (syncRet1);
return syncRet;
}
void plt_init(simulation_result *self,DATA *data, threadData_t *threadData)
{
plt_data *pltData = (plt_data*) malloc(sizeof(plt_data));
rt_tick(SIM_TIMER_OUTPUT);
/*
* Re-Initialization is important because the variables are global and used in every solving step
*/
pltData->simulationResultData = 0;
pltData->currentPos = 0;
pltData->actualPoints = 0; /* the number of actual points saved */
pltData->dataSize = 0;
pltData->maxPoints = self->numpoints;
assertStreamPrint(threadData, self->numpoints >= 0, "Automatic output steps not supported in OpenModelica yet. Set numpoints >= 0.");
pltData->num_vars = calcDataSize(self,data->modelData);
pltData->dataSize = calcDataSize(self,data->modelData);
pltData->simulationResultData = (double*)malloc(self->numpoints * pltData->dataSize * sizeof(double));
if(!pltData->simulationResultData) {
throwStreamPrint(threadData, "Error allocating simulation result data of size %ld failed",self->numpoints * pltData->dataSize);
}
pltData->currentPos = 0;
self->storage = pltData;
rt_accumulate(SIM_TIMER_OUTPUT);
}
void mat4_free(simulation_result *self,DATA *data)
{
mat_data *matData = (mat_data*) self->storage;
rt_tick(SIM_TIMER_OUTPUT);
/* this is a bad programming practice - closing file in destructor,
* where a proper error reporting can't be done
* It's ok now; it's not even C++ code :D
*/
if(matData->fp)
{
try
{
matData->fp.seekp(matData->data2HdrPos);
writeMatVer4MatrixHeader(self,data,"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, matData->ntimepoints, sizeof(double));
matData->fp.close();
}
catch (...)
{
/* just ignore, we are in destructor */
}
}
delete matData;
self->storage = NULL;
rt_accumulate(SIM_TIMER_OUTPUT);
}
static void fmtEmitStep(DATA* data, threadData_t *threadData, MEASURE_TIME* mt, int didEventStep)
{
if(mt->fmtReal)
{
int i, flag=1;
double tmpdbl;
unsigned int tmpint;
int total = data->modelData.modelDataXml.nFunctions + data->modelData.modelDataXml.nProfileBlocks;
rt_tick(SIM_TIMER_OVERHEAD);
rt_accumulate(SIM_TIMER_STEP);
/* Disable time measurements if we have trouble writing to the file... */
flag = flag && 1 == fwrite(&mt->stepNo, sizeof(unsigned int), 1, mt->fmtInt);
mt->stepNo++;
flag = flag && 1 == fwrite(&(data->localData[0]->timeValue), sizeof(double), 1, mt->fmtReal);
tmpdbl = rt_accumulated(SIM_TIMER_STEP);
flag = flag && 1 == fwrite(&tmpdbl, sizeof(double), 1, mt->fmtReal);
flag = flag && total == fwrite(rt_ncall_arr(SIM_TIMER_FIRST_FUNCTION), sizeof(uint32_t), total, mt->fmtInt);
for(i=0; i<data->modelData.modelDataXml.nFunctions + data->modelData.modelDataXml.nProfileBlocks; i++) {
tmpdbl = rt_accumulated(i + SIM_TIMER_FIRST_FUNCTION);
flag = flag && 1 == fwrite(&tmpdbl, sizeof(double), 1, mt->fmtReal);
}
rt_accumulate(SIM_TIMER_OVERHEAD);
if(!flag)
{
warningStreamPrint(LOG_SOLVER, 0, "Disabled time measurements because the output file could not be generated: %s", strerror(errno));
fclose(mt->fmtInt);
fclose(mt->fmtReal);
mt->fmtInt = NULL;
mt->fmtReal = NULL;
}
}
/* prevent emit if noEventEmit flag is used, if it's an event */
if ((omc_flag[FLAG_NOEVENTEMIT] && didEventStep == 0) || !omc_flag[FLAG_NOEVENTEMIT])
{
sim_result.emit(&sim_result, data, threadData);
}
printAllVarsDebug(data, 0, LOG_DEBUG); /* ??? */
}
void mat4_emit(simulation_result *self,DATA *data)
{
mat_data *matData = (mat_data*) self->storage;
double datPoint=0;
rt_tick(SIM_TIMER_OUTPUT);
rt_accumulate(SIM_TIMER_TOTAL);
double cpuTimeValue = rt_accumulated(SIM_TIMER_TOTAL);
rt_tick(SIM_TIMER_TOTAL);
/* this is done wrong -- a buffering should be used
although ofstream does have some buffering, but it is not enough and
not for this purpose */
matData->fp.write((char*)&(data->localData[0]->timeValue), sizeof(double));
if(self->cpuTime)
matData->fp.write((char*)&cpuTimeValue, sizeof(double));
for(int i = 0; i < data->modelData.nVariablesReal; i++) if(!data->modelData.realVarsData[i].filterOutput)
matData->fp.write((char*)&(data->localData[0]->realVars[i]),sizeof(double));
for(int i = 0; i < data->modelData.nVariablesInteger; i++) if(!data->modelData.integerVarsData[i].filterOutput)
{
datPoint = (double) data->localData[0]->integerVars[i];
matData->fp.write((char*)&datPoint,sizeof(double));
}
for(int i = 0; i < data->modelData.nVariablesBoolean; i++) if(!data->modelData.booleanVarsData[i].filterOutput)
{
datPoint = (double) data->localData[0]->booleanVars[i];
matData->fp.write((char*)&datPoint,sizeof(double));
}
for(int i = 0; i < data->modelData.nAliasBoolean; i++) if(!data->modelData.booleanAlias[i].filterOutput)
{
if(data->modelData.booleanAlias[i].negate)
{
datPoint = (double) (data->localData[0]->booleanVars[data->modelData.booleanAlias[i].nameID]==1?0:1);
matData->fp.write((char*)&datPoint,sizeof(double));
}
}
if (!matData->fp) {
throwStreamPrint(data->threadData, "Error while writing file %s",self->filename);
}
++matData->ntimepoints;
rt_accumulate(SIM_TIMER_OUTPUT);
}
void plt_emit(simulation_result *self,DATA *data, threadData_t *threadData)
{
plt_data *pltData = (plt_data*) self->storage;
rt_tick(SIM_TIMER_OUTPUT);
if(pltData->actualPoints < pltData->maxPoints) {
add_result(self,data,pltData->simulationResultData,&pltData->actualPoints); /*used for non-interactive simulation */
} else {
pltData->maxPoints = (long)(1.4*pltData->maxPoints + (pltData->maxPoints-pltData->actualPoints) + 2000);
/* cerr << "realloc simulationResultData to a size of " << maxPoints * dataSize * sizeof(double) << endl; */
pltData->simulationResultData = (double*)realloc(pltData->simulationResultData, pltData->maxPoints * pltData->dataSize * sizeof(double));
if(!pltData->simulationResultData) {
throwStreamPrint(threadData, "Error allocating simulation result data of size %ld",pltData->maxPoints * pltData->dataSize);
}
add_result(self,data,pltData->simulationResultData,&pltData->actualPoints);
}
rt_accumulate(SIM_TIMER_OUTPUT);
}
/*
* output the result before destroying the datastructure.
*/
void plt_free(simulation_result *self,DATA *data, threadData_t *threadData)
{
plt_data *pltData = (plt_data*) self->storage;
const MODEL_DATA *modelData = data->modelData;
int varn = 0, i, var;
FILE* f = NULL;
rt_tick(SIM_TIMER_OUTPUT);
f = fopen(self->filename, "w");
if(!f)
{
deallocResult(pltData);
throwStreamPrint(threadData, "Error, couldn't create output file: [%s] because of %s", self->filename, strerror(errno));
}
/* Rather ugly numbers than unneccessary rounding.
f.precision(std::numeric_limits<double>::digits10 + 1); */
fprintf(f, "#Ptolemy Plot file, generated by OpenModelica\n");
fprintf(f, "#NumberofVariables=%d\n", pltData->num_vars);
fprintf(f, "#IntervalSize=%ld\n", pltData->actualPoints);
fprintf(f, "TitleText: OpenModelica simulation plot\n");
fprintf(f, "XLabel: t\n\n");
/* time variable. */
fprintf(f, "DataSet: time\n");
for(i = 0; i < pltData->actualPoints; ++i)
printPltLine(f, pltData->simulationResultData[i*pltData->num_vars], pltData->simulationResultData[i*pltData->num_vars]);
fprintf(f, "\n");
varn++;
/* $cpuTime variable. */
if(self->cpuTime)
{
fprintf(f, "DataSet: $cpuTime\n");
for(i = 0; i < pltData->actualPoints; ++i)
printPltLine(f, pltData->simulationResultData[i*pltData->num_vars], pltData->simulationResultData[i*pltData->num_vars + 1]);
fprintf(f, "\n");
varn++;
}
for(var = 0; var < modelData->nVariablesReal; ++var)
{
if(!modelData->realVarsData[var].filterOutput) {
fprintf(f, "DataSet: %s\n", modelData->realVarsData[var].info.name);
for(i = 0; i < pltData->actualPoints; ++i)
printPltLine(f, pltData->simulationResultData[i*pltData->num_vars], pltData->simulationResultData[i*pltData->num_vars + varn]);
fprintf(f, "\n");
varn++;
}
}
for(var = 0; var < modelData->nVariablesInteger; ++var)
{
if(!modelData->integerVarsData[var].filterOutput) {
fprintf(f, "DataSet: %s\n", modelData->integerVarsData[var].info.name);
for(i = 0; i < pltData->actualPoints; ++i)
printPltLine(f, pltData->simulationResultData[i*pltData->num_vars], pltData->simulationResultData[i*pltData->num_vars + varn]);
fprintf(f, "\n");
varn++;
}
}
for(var = 0; var < modelData->nVariablesBoolean; ++var)
{
if(!modelData->booleanVarsData[var].filterOutput) {
fprintf(f, "DataSet: %s\n", modelData->booleanVarsData[var].info.name);
for(i = 0; i < pltData->actualPoints; ++i)
printPltLine(f, pltData->simulationResultData[i*pltData->num_vars], pltData->simulationResultData[i*pltData->num_vars + varn]);
fprintf(f, "\n");
varn++;
}
}
for(var = 0; var < modelData->nAliasReal; ++var)
{
if(!modelData->realAlias[var].filterOutput) {
fprintf(f, "DataSet: %s\n", modelData->realAlias[var].info.name);
for(i = 0; i < pltData->actualPoints; ++i)
printPltLine(f, pltData->simulationResultData[i*pltData->num_vars], pltData->simulationResultData[i*pltData->num_vars + varn]);
fprintf(f, "\n");
varn++;
}
}
for(var = 0; var < modelData->nAliasInteger; ++var)
{
if(!modelData->integerAlias[var].filterOutput) {
fprintf(f, "DataSet: %s\n", modelData->integerAlias[var].info.name);
for(i = 0; i < pltData->actualPoints; ++i)
printPltLine(f, pltData->simulationResultData[i*pltData->num_vars], pltData->simulationResultData[i*pltData->num_vars + varn]);
fprintf(f, "\n");
varn++;
}
}
for(var = 0; var < modelData->nAliasBoolean; ++var)
{
if(!modelData->booleanAlias[var].filterOutput) {
fprintf(f, "DataSet: %s\n", modelData->booleanAlias[var].info.name);
for(i = 0; i < pltData->actualPoints; ++i)
printPltLine(f, pltData->simulationResultData[i*pltData->num_vars], pltData->simulationResultData[i*pltData->num_vars + varn]);
fprintf(f, "\n");
varn++;
}
}
deallocResult(pltData);
if(fclose(f))
{
throwStreamPrint(threadData, "Error, couldn't write to output file %s\n", self->filename);
}
free(self->storage);
self->storage = NULL;
rt_accumulate(SIM_TIMER_OUTPUT);
}
/*
* add the values of one step for all variables to the data
* array to be able to later store this on file.
*/
static void add_result(simulation_result *self,DATA *data,double *data_, long *actualPoints)
{
plt_data *pltData = (plt_data*) self->storage;
const DATA *simData = data;
int i;
double cpuTimeValue = 0;
rt_accumulate(SIM_TIMER_TOTAL);
cpuTimeValue = rt_accumulated(SIM_TIMER_TOTAL);
rt_tick(SIM_TIMER_TOTAL);
{
data_[pltData->currentPos++] = simData->localData[0]->timeValue;
if(self->cpuTime)
data_[pltData->currentPos++] = cpuTimeValue;
/* .. reals .. */
for(i = 0; i < simData->modelData->nVariablesReal; i++) {
if(!simData->modelData->realVarsData[i].filterOutput) {
data_[pltData->currentPos++] = simData->localData[0]->realVars[i];
}
}
/* .. integers .. */
for(i = 0; i < simData->modelData->nVariablesInteger; i++) {
if(!simData->modelData->integerVarsData[i].filterOutput) {
data_[pltData->currentPos++] = simData->localData[0]->integerVars[i];
}
}
/* .. booleans .. */
for(i = 0; i < simData->modelData->nVariablesBoolean; i++) {
if(!simData->modelData->booleanVarsData[i].filterOutput) {
data_[pltData->currentPos++] = simData->localData[0]->booleanVars[i];
}
}
/* .. alias reals .. */
for(i = 0; i < simData->modelData->nAliasReal; i++) {
if(!simData->modelData->realAlias[i].filterOutput) {
double value;
if(simData->modelData->realAlias[i].aliasType == 2)
value = (simData->localData[0])->timeValue;
else if(simData->modelData->realAlias[i].aliasType == 1)
value = simData->simulationInfo->realParameter[simData->modelData->realAlias[i].nameID];
else
value = (simData->localData[0])->realVars[simData->modelData->realAlias[i].nameID];
if(simData->modelData->realAlias[i].negate)
data_[pltData->currentPos++] = -value;
else
data_[pltData->currentPos++] = value;
}
}
/* .. alias integers .. */
for(i = 0; i < simData->modelData->nAliasInteger; i++) {
if(!simData->modelData->integerAlias[i].filterOutput) {
modelica_integer value;
if(simData->modelData->integerAlias[i].aliasType == 1)
value = simData->simulationInfo->integerParameter[simData->modelData->realAlias[i].nameID];
else
value = (simData->localData[0])->integerVars[simData->modelData->realAlias[i].nameID];
if(simData->modelData->integerAlias[i].negate)
data_[pltData->currentPos++] = -value;
else
data_[pltData->currentPos++] = value;
}
}
/* .. alias booleans .. */
for(i = 0; i < simData->modelData->nAliasBoolean; i++) {
if(!simData->modelData->booleanAlias[i].filterOutput) {
modelica_boolean value;
if(simData->modelData->integerAlias[i].aliasType == 1)
value = simData->simulationInfo->booleanParameter[simData->modelData->realAlias[i].nameID];
else
value = (simData->localData[0])->booleanVars[simData->modelData->realAlias[i].nameID];
if(simData->modelData->booleanAlias[i].negate)
data_[pltData->currentPos++] = value==1?0:1;
else
data_[pltData->currentPos++] = value;
}
}
}
/*cerr << " ... done" << endl; */
(*actualPoints)++;
}
void mat4_init(simulation_result *self,DATA *data)
{
mat_data *matData = new mat_data();
self->storage = matData;
const MODEL_DATA *mData = &(data->modelData);
const char Aclass[] = "A1 bt. ir1 na Tj re ac nt so r y ";
const struct VAR_INFO** names = NULL;
const int nParams = mData->nParametersReal + mData->nParametersInteger + mData->nParametersBoolean;
char *stringMatrix = NULL;
int rows, cols;
int32_t *intMatrix = NULL;
double *doubleMatrix = NULL;
assert(sizeof(char) == 1);
rt_tick(SIM_TIMER_OUTPUT);
matData->numVars = calcDataSize(self,data);
names = calcDataNames(self,data,matData->numVars+nParams);
matData->data1HdrPos = -1;
matData->data2HdrPos = -1;
matData->ntimepoints = 0;
matData->startTime = data->simulationInfo.startTime;
matData->stopTime = data->simulationInfo.stopTime;
try {
/* open file */
matData->fp.open(self->filename, std::ofstream::binary|std::ofstream::trunc);
if(!matData->fp) {
throwStreamPrint(data->threadData, "Cannot open File %s for writing",self->filename);
}
/* write `AClass' matrix */
writeMatVer4Matrix(self,data,"Aclass", 4, 11, Aclass, sizeof(int8_t));
/* flatten variables' names */
flattenStrBuf(matData->numVars+nParams, names, stringMatrix, rows, cols, false /* We cannot plot derivatives if we fix the names ... */, false);
/* write `name' matrix */
writeMatVer4Matrix(self,data,"name", rows, cols, stringMatrix, sizeof(int8_t));
free(stringMatrix);
stringMatrix = NULL;
/* flatten variables' comments */
flattenStrBuf(matData->numVars+nParams, names, stringMatrix, rows, cols, false, true);
/* write `description' matrix */
writeMatVer4Matrix(self,data,"description", rows, cols, stringMatrix, sizeof(int8_t));
free(stringMatrix);
stringMatrix = NULL;
/* generate dataInfo table */
generateDataInfo(self, data, intMatrix, rows, cols, matData->numVars, nParams);
/* write `dataInfo' matrix */
writeMatVer4Matrix(self, data, "dataInfo", cols, rows, intMatrix, sizeof(int32_t));
/* remember data1HdrPos */
matData->data1HdrPos = matData->fp.tellp();
/* adrpo: i cannot use writeParameterData here as it would return back to dataHdr1Pos */
/* generate `data_1' matrix (with parameter data) */
generateData_1(data, doubleMatrix, rows, cols, matData->startTime, matData->stopTime);
/* write `data_1' matrix */
writeMatVer4Matrix(self,data,"data_1", cols, rows, doubleMatrix, sizeof(double));
/* remember data2HdrPos */
matData->data2HdrPos = matData->fp.tellp();
/* write `data_2' header */
writeMatVer4MatrixHeader(self,data,"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, 0, sizeof(double));
free(doubleMatrix);
free(intMatrix);
doubleMatrix = NULL;
intMatrix = NULL;
matData->fp.flush();
}
catch(...)
{
matData->fp.close();
free(names);
names=NULL;
free(stringMatrix);
free(doubleMatrix);
free(intMatrix);
rt_accumulate(SIM_TIMER_OUTPUT);
throwStreamPrint(data->threadData, "Error while writing mat file %s",self->filename);
}
free(names);
names=NULL;
rt_accumulate(SIM_TIMER_OUTPUT);
}