double VisualizerMAT::omcGetVarValue(ModelicaMatReader* reader, const char* varName, double time)
{
double val = 0.0;
ModelicaMatVariable_t* var = nullptr;
var = omc_matlab4_find_var(reader, varName);
if (var == nullptr)
std::cout<<"Did not get variable from result file. Variable name is "<<std::string(varName)<<std::endl;
else
omc_matlab4_val(&val, reader, var, time);
return val;
}
int SimulationResults_filterSimulationResults(const char *inFile, const char *outFile, void *vars, int numberOfIntervals)
{
const char *msg[5] = {"","","","",""};
void *tmp;
if (UNKNOWN_PLOT == SimulationResultsImpl__openFile(inFile, &simresglob)) {
return 0;
}
vars = mmc_mk_cons(mmc_mk_scon("time"),vars);
switch (simresglob.curFormat) {
case MATLAB4: {
int numToFilter = listLength(vars);
int i, j;
int numUnique = 0;
int numUniqueParam = 1;
int longestName = 0;
int longestDesc = 0;
ModelicaMatVariable_t **mat_var = omc_alloc_interface.malloc(numToFilter*sizeof(ModelicaMatVariable_t*));
int *indexes = (int*) omc_alloc_interface.malloc(simresglob.matReader.nvar*sizeof(int)); /* Need it to be zeros; note that the actual number of indexes is smaller */
int *parameter_indexes = (int*) omc_alloc_interface.malloc(simresglob.matReader.nparam*sizeof(int)); /* Need it to be zeros; note that the actual number of indexes is smaller */
int *indexesToOutput = NULL;
int *parameter_indexesToOutput = NULL;
FILE *fout = NULL;
char *tmp;
double start_stop[2] = {0};
double start = omc_matlab4_startTime(&simresglob.matReader);
double stop = omc_matlab4_stopTime(&simresglob.matReader);
parameter_indexes[0] = 1; /* time */
omc_matlab4_read_all_vals(&simresglob.matReader);
if (endsWith(outFile,".csv")) {
double **vals = omc_alloc_interface.malloc(sizeof(double*)*numToFilter);
FILE *fout = NULL;
for (i=0; i<numToFilter; i++) {
const char *var = MMC_STRINGDATA(MMC_CAR(vars));
vars = MMC_CDR(vars);
mat_var[i] = omc_matlab4_find_var(&simresglob.matReader, var);
if (mat_var[i] == NULL) {
msg[0] = SystemImpl__basename(inFile);
msg[1] = var;
c_add_message(NULL,-1, ErrorType_scripting, ErrorLevel_error, gettext("Could not read variable %s in file %s."), msg, 2);
return 0;
}
if (mat_var[i]->isParam) {
msg[0] = var;
c_add_message(NULL,-1, ErrorType_scripting, ErrorLevel_error, gettext("Could not filter parameter %s since the output format is CSV (only variables are allowed)."), msg, 1);
return 0;
} else {
vals[i] = omc_matlab4_read_vals(&simresglob.matReader, mat_var[i]->index);
}
}
fout = fopen(outFile, "w");
fprintf(fout, "time");
for (i=1; i<numToFilter; i++) {
fprintf(fout, ",\"%s\"", mat_var[i]->name);
}
fprintf(fout, ",nrows=%d\n", simresglob.matReader.nrows);
for (i=0; i<simresglob.matReader.nrows; i++) {
fprintf(fout, "%.15g", vals[0][i]);
for (j=1; j<numToFilter; j++) {
fprintf(fout, ",%.15g", vals[j][i]);
}
fprintf(fout, "\n");
}
fclose(fout);
return 1;
} /* Not CSV */
for (i=0; i<numToFilter; i++) {
const char *var = MMC_STRINGDATA(MMC_CAR(vars));
vars = MMC_CDR(vars);
mat_var[i] = omc_matlab4_find_var(&simresglob.matReader,var);
if (mat_var[i] == NULL) {
msg[0] = SystemImpl__basename(inFile);
msg[1] = var;
c_add_message(NULL,-1, ErrorType_scripting, ErrorLevel_error, gettext("Could not read variable %s in file %s."), msg, 2);
return 0;
}
if (mat_var[i]->isParam) {
/* Store the old index in the array */
if (0==parameter_indexes[abs(mat_var[i]->index)-1]++) {
numUniqueParam++;
}
} else {
/* Store the old index in the array */
if (0==indexes[abs(mat_var[i]->index)-1]++) {
numUnique++;
}
}
longestName = intMax(longestName, strlen(mat_var[i]->name));
longestDesc = intMax(longestDesc, strlen(mat_var[i]->descr));
}
/* Create the list of variable indexes to output */
indexesToOutput = omc_alloc_interface.malloc_atomic(numUnique * sizeof(int));
parameter_indexesToOutput = omc_alloc_interface.malloc_atomic(numUniqueParam * sizeof(int));
j=0;
for (i=0; i<simresglob.matReader.nvar; i++) {
if (indexes[i]) {
indexesToOutput[j++] = i+1;
}
/* indexes becomes the lookup table from old index to new index */
indexes[i] = j;
}
j=0;
for (i=0; i<simresglob.matReader.nparam; i++) {
if (parameter_indexes[i]) {
parameter_indexesToOutput[j++] = i+1;
}
/* indexes becomes the lookup table from old index to new index */
parameter_indexes[i] = j;
}
fout = fopen(outFile, "wb");
if (fout == NULL) {
return failedToWriteToFile(outFile);
}
/* Matrix list: "Aclass" "name" "description" "dataInfo" "data_1" "data_2" */
if (writeMatVer4AclassNormal(fout)) {
return failedToWriteToFile(outFile);
}
if (writeMatVer4MatrixHeader(fout, "name", numToFilter, longestName, sizeof(int8_t))) {
return failedToWriteToFile(outFile);
}
tmp = omc_alloc_interface.malloc(numToFilter*longestName);
for (i=0; i<numToFilter; i++) {
int len = strlen(mat_var[i]->name);
for (j=0; j<len; j++) {
tmp[numToFilter*j+i] = mat_var[i]->name[j];
}
}
if (1 != fwrite(tmp, numToFilter*longestName, 1, fout)) {
return failedToWriteToFile(outFile);
}
GC_free(tmp);
if (writeMatVer4MatrixHeader(fout, "description", numToFilter, longestDesc, sizeof(int8_t))) {
return failedToWriteToFile(outFile);
}
tmp = omc_alloc_interface.malloc(numToFilter*longestDesc);
for (i=0; i<numToFilter; i++) {
int len = strlen(mat_var[i]->descr);
for (j=0; j<len; j++) {
tmp[numToFilter*j+i] = mat_var[i]->descr[j];
}
}
if (1 != fwrite(tmp, numToFilter*longestDesc, 1, fout)) {
return failedToWriteToFile(outFile);
}
GC_free(tmp);
if (writeMatVer4MatrixHeader(fout, "dataInfo", numToFilter, 4, sizeof(int32_t))) {
return failedToWriteToFile(outFile);
}
for (i=0; i<numToFilter; i++) {
int32_t x = mat_var[i]->isParam ? 1 : 2; /* data_1 or data_2 */
if (1 != fwrite(&x, sizeof(int32_t), 1, fout)) {
return failedToWriteToFile(outFile);
}
}
for (i=0; i<numToFilter; i++) {
int32_t x = (mat_var[i]->index < 0 ? -1 : 1) * (mat_var[i]->isParam ? parameter_indexes[abs(mat_var[i]->index)-1] : indexes[abs(mat_var[i]->index)-1]);
if (1 != fwrite(&x, sizeof(int32_t), 1, fout)) {
return failedToWriteToFile(outFile);
}
}
for (i=0; i<numToFilter; i++) {
int32_t x = 0; /* linear interpolation */
if (1 != fwrite(&x, sizeof(int32_t), 1, fout)) {
return failedToWriteToFile(outFile);
}
}
for (i=0; i<numToFilter; i++) {
int32_t x = -1; /* not defined outside the time interval */
if (1 != fwrite(&x, sizeof(int32_t), 1, fout)) {
return failedToWriteToFile(outFile);
}
}
if (writeMatVer4MatrixHeader(fout, "data_1", 2, numUniqueParam, sizeof(double))) {
return failedToWriteToFile(outFile);
}
start = omc_matlab4_startTime(&simresglob.matReader);
stop = omc_matlab4_stopTime(&simresglob.matReader);
start_stop[0]=start;
start_stop[1]=stop;
if (1 != fwrite(start_stop, sizeof(double)*2, 1, fout)) {
return failedToWriteToFile(outFile);
}
for (i=1; i<numUniqueParam; i++) {
int paramIndex = parameter_indexesToOutput[i];
double d[2] = {simresglob.matReader.params[abs(paramIndex)-1],0};
d[1] = d[0];
if (1!=fwrite(d, sizeof(double)*2, 1, fout)) {
return failedToWriteToFile(outFile);
}
}
if (numberOfIntervals) {
double *timevals = omc_matlab4_read_vals(&simresglob.matReader, 1);
int last_found=0;
int nevents=0, neventpoints=0;
for (i=1; i<numberOfIntervals; i++) {
double t = start + (stop-start)*((double)i)/numberOfIntervals;
while (timevals[j]<=t) {
if (timevals[j]==timevals[j+1]) {
while (timevals[j]==timevals[j+1]) {
j++;
neventpoints++;
}
nevents++;
}
j++;
}
}
msg[4] = inFile;
GC_asprintf((char**)msg+3, "%d", simresglob.matReader.nrows);
GC_asprintf((char**)msg+2, "%d", numberOfIntervals);
GC_asprintf((char**)msg+1, "%d", nevents);
GC_asprintf((char**)msg+0, "%d", neventpoints);
c_add_message(NULL,-1, ErrorType_scripting, ErrorLevel_notification, gettext("Resampling %s from %s points to %s points, removing %s events stored in %s points.\n"), msg, 5);
}
if (writeMatVer4MatrixHeader(fout, "data_2", numberOfIntervals ? numberOfIntervals+1 : simresglob.matReader.nrows, numUnique, sizeof(double))) {
return failedToWriteToFile(outFile);
}
for (i=0; i<numUnique; i++) {
double *vals = NULL;
int nrows;
if (numberOfIntervals) {
omc_matlab4_read_all_vals(&simresglob.matReader);
nrows = numberOfIntervals+1;
vals = omc_alloc_interface.malloc_atomic(sizeof(double)*nrows);
for (j=0; j<=numberOfIntervals; j++) {
double t = j==numberOfIntervals ? stop : start + (stop-start)*((double)j)/numberOfIntervals;
ModelicaMatVariable_t var = {0};
var.name="";
var.descr="";
var.isParam=0;
var.index=indexesToOutput[i];
if (omc_matlab4_val(vals+j, &simresglob.matReader, &var, t)) {
msg[2] = inFile;
GC_asprintf((char**)msg+1, "%d", indexesToOutput[i]);
GC_asprintf((char**)msg+0, "%.15g", t);
c_add_message(NULL,-1, ErrorType_scripting, ErrorLevel_error, gettext("Resampling %s failed to get variable %s at time %s.\n"), msg, 3);
return 0;
}
}
} else {
vals = omc_matlab4_read_vals(&simresglob.matReader, indexesToOutput[i]);
nrows = simresglob.matReader.nrows;
}
if (1!=fwrite(vals, sizeof(double)*nrows, 1, fout)) {
return failedToWriteToFile(outFile);
}
if (numberOfIntervals) {
GC_free(vals);
}
}
fclose(fout);
return 1;
}
default:
msg[0] = PlotFormatStr[simresglob.curFormat];
c_add_message(NULL,-1, ErrorType_scripting, ErrorLevel_error, gettext("filterSimulationResults not implemented for plot format: %s\n"), msg, 1);
return 0;
}
}
static void* SimulationResultsImpl__readDataset(const char *filename, void *vars, int dimsize, int suggestReadAllVars, SimulationResult_Globals* simresglob, int runningTestsuite)
{
const char *msg[2] = {"",""};
void *res,*col;
char *var;
double *vals;
int i;
if (UNKNOWN_PLOT == SimulationResultsImpl__openFile(filename,simresglob)) {
return NULL;
}
res = mmc_mk_nil();
switch (simresglob->curFormat) {
case MATLAB4: {
ModelicaMatVariable_t *mat_var;
if (dimsize == 0) {
dimsize = simresglob->matReader.nrows;
} else if (simresglob->matReader.nrows != dimsize) {
fprintf(stderr, "dimsize: %d, rows %d\n", dimsize, simresglob->matReader.nrows);
c_add_message(NULL,-1, ErrorType_scripting, ErrorLevel_error, gettext("readDataset(...): Expected and actual dimension sizes do not match."), NULL, 0);
return NULL;
}
if (suggestReadAllVars) {
omc_matlab4_read_all_vals(&simresglob->matReader);
}
while (MMC_NILHDR != MMC_GETHDR(vars)) {
var = MMC_STRINGDATA(MMC_CAR(vars));
vars = MMC_CDR(vars);
mat_var = omc_matlab4_find_var(&simresglob->matReader,var);
if (mat_var == NULL) {
msg[0] = runningTestsuite ? SystemImpl__basename(filename) : filename;
msg[1] = var;
c_add_message(NULL,-1, ErrorType_scripting, ErrorLevel_error, gettext("Could not read variable %s in file %s."), msg, 2);
return NULL;
} else if (mat_var->isParam) {
col=mmc_mk_nil();
for (i=0;i<dimsize;i++) col=mmc_mk_cons(mmc_mk_rcon((mat_var->index<0)?-simresglob->matReader.params[abs(mat_var->index)-1]:simresglob->matReader.params[abs(mat_var->index)-1]),col);
res = mmc_mk_cons(col,res);
} else {
vals = omc_matlab4_read_vals(&simresglob->matReader,mat_var->index);
col=mmc_mk_nil();
for (i=0;i<dimsize;i++) col=mmc_mk_cons(mmc_mk_rcon(vals[i]),col);
res = mmc_mk_cons(col,res);
}
}
return res;
}
case PLT: {
return read_ptolemy_dataset(filename,vars,dimsize);
}
case CSV: {
while (MMC_NILHDR != MMC_GETHDR(vars)) {
var = MMC_STRINGDATA(MMC_CAR(vars));
vars = MMC_CDR(vars);
vals = simresglob->csvReader ? read_csv_dataset(simresglob->csvReader,var) : NULL;
if (vals == NULL) {
msg[0] = runningTestsuite ? SystemImpl__basename(filename) : filename;
msg[1] = var;
c_add_message(NULL,-1, ErrorType_scripting, ErrorLevel_error, gettext("Could not read variable %s in file %s."), msg, 2);
return NULL;
} else {
col=mmc_mk_nil();
for (i=0;i<dimsize;i++) {
col=mmc_mk_cons(mmc_mk_rcon(vals[i]),col);
}
res = mmc_mk_cons(col,res);
}
}
return res;
}
default:
msg[0] = PlotFormatStr[simresglob->curFormat];
c_add_message(NULL,-1, ErrorType_scripting, ErrorLevel_error, gettext("readDataSet() not implemented for plot format: %s\n"), msg, 1);
return NULL;
}
}
static double SimulationResultsImpl__val(const char *filename, const char *varname, double timeStamp, SimulationResult_Globals* simresglob)
{
double res;
const char *msg[4] = {"","","",""};
if (UNKNOWN_PLOT == SimulationResultsImpl__openFile(filename,simresglob)) {
return NAN;
}
switch (simresglob->curFormat) {
case MATLAB4: {
ModelicaMatVariable_t *var;
if (0 == (var=omc_matlab4_find_var(&simresglob->matReader,varname))) {
msg[1] = varname;
msg[0] = filename;
c_add_message(NULL,-1, ErrorType_scripting, ErrorLevel_error, gettext("%s not found in %s\n"), msg, 2);
return NAN;
}
if (omc_matlab4_val(&res,&simresglob->matReader,var,timeStamp)) {
char buf[64],buf2[64],buf3[64];
snprintf(buf,60,"%g",timeStamp);
snprintf(buf2,60,"%g",omc_matlab4_startTime(&simresglob->matReader));
snprintf(buf3,60,"%g",omc_matlab4_stopTime(&simresglob->matReader));
msg[3] = varname;
msg[2] = buf;
msg[1] = buf2;
msg[0] = buf3;
c_add_message(NULL,-1, ErrorType_scripting, ErrorLevel_error, gettext("%s not defined at time %s (startTime=%s, stopTime=%s)."), msg, 4);
return NAN;
}
return res;
}
case PLT: {
char *strToFind = (char*) malloc(strlen(varname)+30);
char line[255];
double pt,t,pv,v,w1,w2;
int nread=0;
sprintf(strToFind,"DataSet: %s\n",varname);
fseek(simresglob->pltReader,0,SEEK_SET);
do {
if (NULL==fgets(line,255,simresglob->pltReader)) {
msg[1] = varname;
msg[0] = filename;
c_add_message(NULL,-1, ErrorType_scripting, ErrorLevel_error, gettext("%s not found in %s\n"), msg, 2);
return NAN;
}
} while (strcmp(strToFind,line));
free(strToFind);
while (fscanf(simresglob->pltReader,"%lg, %lg\n",&t,&v) == 2) {
nread++;
if (t > timeStamp) break;
pt = t;
pv = v;
};
if (nread == 0 || nread == 1 || t < timeStamp) {
char buf[64];
snprintf(buf,60,"%g",timeStamp);
msg[1] = varname;
msg[0] = buf;
c_add_message(NULL,-1, ErrorType_scripting, ErrorLevel_error, gettext("%s not defined at time %s\n"), msg, 2);
return NAN;
} else {
/* Linear interpolation */
if ((t-pt) == 0.0) return v;
w1 = (timeStamp - pt) / (t-pt);
w2 = 1.0 - w1;
return pv*w2 + v*w1;
}
}
default:
msg[0] = PlotFormatStr[simresglob->curFormat];
c_add_message(NULL,-1, ErrorType_scripting, ErrorLevel_error, gettext("val() not implemented for plot format: %s\n"), msg, 1);
return NAN;
}
}
/**
* Uses OpenModelica functions to read from .mat files : faster than csv (both writing and reading)
* @note : don't forget to free reader (omc_free_matlab4_reader()) in order to let files writable
*/
bool OpenModelica::getFinalVariablesFromMatFile(QString fileName, MOVector<Variable> * variables,QString _modelName)
{
ModelicaMatReader reader;
ModelicaMatVariable_t *var;
const char* msg;
double value;
bool varOk;
int status ;
Variable* newVar;
//Read in mat file
if(0 != (msg = omc_new_matlab4_reader(fileName.toStdString().c_str(), &reader)))
{
InfoSender::instance()->sendError("Unable to read .mat file: "+QString(msg));
#ifdef WIN32 // don't know why sigabrt on linux. Should look for.
delete[] msg;
#endif
return false;
}
// delete[] msg;
//Read in timevector
double stopTime = omc_matlab4_stopTime(&reader);
if (reader.nvar < 1)
{
InfoSender::instance()->sendError("Unable to read .mat file : no variable inside");
omc_free_matlab4_reader(&reader);
return false;
}
// read in all values
for (int i = 0; i < reader.nall; i++)
{
newVar = new Variable();
QString name(reader.allInfo[i].name);
newVar->setName(name);
newVar->setModel(_modelName);
// read the variable final value
var = omc_matlab4_find_var(&reader, reader.allInfo[i].name);
if (!var->isParam)
{
status = omc_matlab4_val(&value,&reader,var,stopTime);
}
// if variable is a parameter then take at first step
else
{
status = omc_matlab4_val(&value,&reader,var,0.0);
}
varOk = (status==0);
if(!varOk && reader.nrows>0)
{
double *vals = omc_matlab4_read_vals(&reader,var->index);
value = vals[reader.nrows-1];
varOk = true;
}
newVar->setValue(value);
if(varOk)
variables->addItem(newVar);
else
{
InfoSender::instance()->debug("Couldn't find value of variable in .mat file :" + newVar->name());
delete newVar;
}
}
omc_free_matlab4_reader(&reader);
return true;
}
/*! \fn int importStartValues(DATA *data, const char *pInitFile, const double initTime)
*
* \param [ref] [data]
* \param [in] [pInitFile]
* \param [in] [initTime]
*
* \author lochel
*/
int importStartValues(DATA *data, threadData_t *threadData, const char *pInitFile, const double initTime)
{
ModelicaMatReader reader;
ModelicaMatVariable_t *pVar = NULL;
double value;
const char *pError = NULL;
char* newVarname = NULL;
MODEL_DATA *mData = data->modelData;
long i;
infoStreamPrint(LOG_INIT, 0, "import start values\nfile: %s\ntime: %g", pInitFile, initTime);
if(!strcmp(data->modelData->resultFileName, pInitFile))
{
errorStreamPrint(LOG_INIT, 0, "Cannot import a result file for initialization that is also the current output file <%s>.\nConsider redirecting the output result file (-r=<new_res.mat>) or renaming the result file that is used for initialization import.", pInitFile);
return 1;
}
pError = omc_new_matlab4_reader(pInitFile, &reader);
if(pError)
{
throwStreamPrint(threadData, "unable to read input-file <%s> [%s]", pInitFile, pError);
return 1;
}
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);
if(!pVar) {
newVarname = mapToDymolaVars(mData->realVarsData[i].info.name);
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);
} else if((strlen(mData->realVarsData[i].info.name) > 0) &&
(mData->realVarsData[i].info.name[0] != '$') &&
(strncmp(mData->realVarsData[i].info.name, "der($", 5) != 0)) {
/* skip warnings about self-generated variables */
warningStreamPrint(LOG_INIT, 0, "unable to import real variable %s from given file", mData->realVarsData[i].info.name);
}
}
infoStreamPrint(LOG_INIT, 0, "import real parameters");
for(i=0; i<mData->nParametersReal; ++i) {
pVar = omc_matlab4_find_var(&reader, mData->realParameterData[i].info.name);
if(!pVar) {
newVarname = mapToDymolaVars(mData->realParameterData[i].info.name);
pVar = omc_matlab4_find_var(&reader, newVarname);
free(newVarname);
}
if(pVar) {
omc_matlab4_val(&(mData->realParameterData[i].attribute.start), &reader, pVar, initTime);
data->simulationInfo->realParameter[i] = mData->realParameterData[i].attribute.start;
infoStreamPrint(LOG_INIT, 0, "| %s(start=%g)", mData->realParameterData[i].info.name, mData->realParameterData[i].attribute.start);
} else {
warningStreamPrint(LOG_INIT, 0, "unable to import real parameter %s from given file", mData->realParameterData[i].info.name);
}
}
infoStreamPrint(LOG_INIT, 0, "import real discrete");
for(i=mData->nVariablesReal-mData->nDiscreteReal; i<mData->nDiscreteReal; ++i) {
pVar = omc_matlab4_find_var(&reader, mData->realParameterData[i].info.name);
if(!pVar) {
newVarname = mapToDymolaVars(mData->realParameterData[i].info.name);
pVar = omc_matlab4_find_var(&reader, newVarname);
free(newVarname);
}
if(pVar) {
omc_matlab4_val(&(mData->realParameterData[i].attribute.start), &reader, pVar, initTime);
infoStreamPrint(LOG_INIT, 0, "| %s(start=%g)", mData->realParameterData[i].info.name, mData->realParameterData[i].attribute.start);
} else {
warningStreamPrint(LOG_INIT, 0, "unable to import real parameter %s from given file", mData->realParameterData[i].info.name);
}
}
infoStreamPrint(LOG_INIT, 0, "import integer parameters");
for(i=0; i<mData->nParametersInteger; ++i)
{
pVar = omc_matlab4_find_var(&reader, mData->integerParameterData[i].info.name);
if (!pVar) {
newVarname = mapToDymolaVars(mData->integerParameterData[i].info.name);
pVar = omc_matlab4_find_var(&reader, newVarname);
free(newVarname);
}
if (pVar) {
omc_matlab4_val(&value, &reader, pVar, initTime);
mData->integerParameterData[i].attribute.start = (modelica_integer)value;
data->simulationInfo->integerParameter[i] = (modelica_integer)value;
infoStreamPrint(LOG_INIT, 0, "| %s(start=%ld)", mData->integerParameterData[i].info.name, mData->integerParameterData[i].attribute.start);
} else {
warningStreamPrint(LOG_INIT, 0, "unable to import integer parameter %s from given file", mData->integerParameterData[i].info.name);
}
}
infoStreamPrint(LOG_INIT, 0, "import boolean parameters");
for(i=0; i<mData->nParametersBoolean; ++i) {
pVar = omc_matlab4_find_var(&reader, mData->booleanParameterData[i].info.name);
if(!pVar) {
newVarname = mapToDymolaVars(mData->booleanParameterData[i].info.name);
pVar = omc_matlab4_find_var(&reader, newVarname);
free(newVarname);
}
if(pVar) {
omc_matlab4_val(&value, &reader, pVar, initTime);
mData->booleanParameterData[i].attribute.start = (modelica_boolean)value;
data->simulationInfo->booleanParameter[i] = (modelica_boolean)value;
infoStreamPrint(LOG_INIT, 0, "| %s(start=%s)", mData->booleanParameterData[i].info.name, mData->booleanParameterData[i].attribute.start ? "true" : "false");
} else {
warningStreamPrint(LOG_INIT, 0, "unable to import boolean parameter %s from given file", mData->booleanParameterData[i].info.name);
}
}
omc_free_matlab4_reader(&reader);
}
return 0;
}
