/*!
* pick up start values from csv for states
* author: Vitalij Ruge
**/
static inline void pickUpStates(OptData* optData){
char* cflags;
cflags = (char*)omc_flagValue[FLAG_INPUT_FILE_STATES];
if(cflags){
FILE * pFile = NULL;
pFile = fopen(cflags,"r");
if(pFile == NULL){
warningStreamPrint(LOG_STDOUT, 0, "OMC can't find the file %s.",cflags);
}else{
int c, n = 0;
modelica_boolean b;
while(1){
c = fgetc(pFile);
if (c==EOF) break;
if (c=='\n') ++n;
}
// check if csv file is empty!
if(n == 0){
fprintf(stderr, "External input file: externalInput.csv is empty!\n"); fflush(NULL);
EXIT(1);
}else{
int i, j;
double start_value;
char buffer[200];
const int nReal = optData->data->modelData.nVariablesReal;
rewind(pFile);
for(i =0; i< n; ++i){
fscanf(pFile, "%s", buffer);
if (fscanf(pFile, "%lf", &start_value) <= 0) continue;
for(j = 0, b = 0; j < nReal; ++j){
if(!strcmp(optData->data->modelData.realVarsData[j].info.name, buffer)){
optData->data->localData[0]->realVars[j] = start_value;
optData->data->localData[1]->realVars[j] = start_value;
optData->data->localData[2]->realVars[j] = start_value;
optData->v0[i] = start_value;
b = 1;
continue;
}
}
if(!b)
warningStreamPrint(LOG_STDOUT, 0, "it was impossible to set %s.start %g", buffer,start_value);
else
printf("\n[%i]set %s.start %g", i, buffer,start_value);
}
fclose(pFile);
printf("\n");
/*update system*/
optData->data->callback->input_function(optData->data);
/*optData->data->callback->functionDAE(optData->data);*/
updateDiscreteSystem(optData->data);
}
}
}
}
static void retrySimulationStep(DATA* data, threadData_t *threadData, SOLVER_INFO* solverInfo)
{
/* reduce step size by a half and try again */
solverInfo->laststep = solverInfo->currentTime - solverInfo->laststep;
/* restore old values and try another step with smaller step-size by dassl*/
restoreOldValues(data);
solverInfo->currentTime = data->localData[0]->timeValue;
overwriteOldSimulationData(data);
updateDiscreteSystem(data, threadData);
warningStreamPrint(LOG_STDOUT, 0, "Integrator attempt to handle a problem with a called assert.");
solverInfo->didEventStep = 1;
}
/*!
* helper optData2ModelData
* author: Vitalij Ruge
**/
static inline void updateDOSystem(OptData * optData, DATA * data, threadData_t *threadData,
const int i, const int j, const int index, const int m){
/* try */
optData->scc = 0;
#if !defined(OMC_EMCC)
MMC_TRY_INTERNAL(simulationJumpBuffer)
#endif
data->callback->input_function(data);
/*data->callback->functionDAE(data);*/
updateDiscreteSystem(data);
if(index){
diffSynColoredOptimizerSystem(optData, optData->J[i][j], i, j, m);
}
optData->scc = 1;
#if !defined(OMC_EMCC)
MMC_CATCH_INTERNAL(simulationJumpBuffer)
#endif
}
/*!
* write results in result file
* author: Vitalij Ruge
**/
void res2file(OptData *optData, SOLVER_INFO* solverInfo, double *vopt){
const int nu = optData->dim.nu;
const int nx = optData->dim.nx;
const int nv = optData->dim.nv;
const int nsi = optData->dim.nsi;
const int np = optData->dim.np;
const int nReal = optData->dim.nReal;
const int nBoolean = optData->data->modelData.nVariablesBoolean;
const int nInteger = optData->data->modelData.nVariablesInteger;
const int nRelations = optData->data->modelData.nRelations;
const int nvnp = nv*np;
long double a[np];
modelica_real *** v = optData->v;
float tmp_u;
int i,j,k, ii, jj;
char buffer[4096];
DATA * data = optData->data;
SIMULATION_DATA *sData = (SIMULATION_DATA*)data->localData[0];
FILE * pFile = optData->pFile;
double * v0 = optData->v0;
double *vnom = optData->bounds.vnom;
long double **t = optData->time.t;
long double t0 = optData->time.t0;
long double tmpv;
if(np == 3){
a[0] = 1.5580782047249223824319753706862790293163070736617;
a[1] = -0.89141153805825571576530870401961236264964040699507;
a[2] = 0.33333333333333333333333333333333333333333333333333;
}else if(np == 1){
a[0] = 1.000;
}else{
errorStreamPrint(LOG_STDOUT, 0, "Not support np = %i", np);
assert(0);
}
optData2ModelData(optData, vopt, 0);
/******************/
fprintf(pFile, "%lf ",(double)t0);
for(i=0,j = nx; i < nu; ++i,++j){
for(k = 0, tmpv = 0.0; k < np; ++k){
tmpv += a[k]*vopt[k*nv + j];
}
tmpv = fmin(fmax(tmpv,optData->bounds.vmin[j]),optData->bounds.vmax[j]);
data->simulationInfo.inputVars[i] = (double)tmpv*vnom[j];
fprintf(pFile, "%lf ", (float)data->simulationInfo.inputVars[i]);
}
fprintf(pFile, "%s", "\n");
/******************/
memcpy(sData->realVars, v0, nReal*sizeof(modelica_real));
memcpy(data->localData[0]->integerVars, optData->i0, nInteger*sizeof(modelica_integer));
memcpy(data->localData[0]->booleanVars, optData->b0, nBoolean*sizeof(modelica_boolean));
memcpy(data->simulationInfo.integerVarsPre, optData->i0Pre, nInteger*sizeof(modelica_integer));
memcpy(data->simulationInfo.booleanVarsPre, optData->b0Pre, nBoolean*sizeof(modelica_boolean));
memcpy(data->simulationInfo.realVarsPre, optData->v0Pre, nReal*sizeof(modelica_real));
memcpy(data->simulationInfo.relationsPre, optData->rePre, nRelations*sizeof(modelica_boolean));
memcpy(data->simulationInfo.relations, optData->re, nRelations*sizeof(modelica_boolean));
memcpy(data->simulationInfo.storedRelations, optData->storeR, nRelations*sizeof(modelica_boolean));
/******************/
solverInfo->currentTime = (double)t0;
sData->timeValue = solverInfo->currentTime;
/*updateDiscreteSystem(data);*/
data->callback->input_function(data);
/*data->callback->functionDAE(data);*/
updateDiscreteSystem(data);
sim_result.emit(&sim_result,data);
/******************/
for(ii = 0; ii < nsi; ++ii){
for(jj = 0; jj < np; ++jj){
/******************/
memcpy(sData->realVars, v[ii][jj], nReal*sizeof(modelica_real));
/******************/
fprintf(pFile, "%lf ",(double)t[ii][jj]);
for(i = 0; i < nu; ++i){
tmp_u = (float)(vopt[ii*nvnp+jj*nv+nx+i]*vnom[i + nx]);
fprintf(pFile, "%lf ", tmp_u);
}
fprintf(pFile, "%s", "\n");
/******************/
solverInfo->currentTime = (double)t[ii][jj];
sData->timeValue = solverInfo->currentTime;
sim_result.emit(&sim_result,data);
}
}
fclose(pFile);
}
