void updateNodeData(LIST *list, LIST_NODE *node, const void *data)
{
assertStreamPrint(NULL, 0 != list, "invalid list-pointer");
assertStreamPrint(NULL, 0 != node, "invalid list-node");
assertStreamPrint(NULL, 0 != node->data, "invalid data node");
memcpy(node->data, data, list->itemSize);
return;
}
LIST_NODE* updateNodeNext(LIST *list, LIST_NODE *node, LIST_NODE *newNext)
{
LIST_NODE *next;
assertStreamPrint(NULL, 0 != list, "invalid list-pointer");
assertStreamPrint(NULL, 0 != node, "invalid list-node");
next = node->next;
node->next = newNext;
return next;
}
/*! \fn allocate memory for nonlinear system solver hybrd
*
*/
int allocateHybrdData(int size, void** voiddata)
{
DATA_HYBRD* data = (DATA_HYBRD*) malloc(sizeof(DATA_HYBRD));
*voiddata = (void*)data;
assertStreamPrint(NULL, 0 != data, "allocationHybrdData() failed!");
data->initialized = 0;
data->resScaling = (double*) malloc(size*sizeof(double));
data->fvecScaled = (double*) malloc(size*sizeof(double));
data->useXScaling = 1;
data->xScalefactors = (double*) malloc(size*sizeof(double));
data->n = size;
data->x = (double*) malloc(size*sizeof(double));
data->xSave = (double*) malloc(size*sizeof(double));
data->xScaled = (double*) malloc(size*sizeof(double));
data->fvec = (double*) calloc(size, sizeof(double));
data->fvecSave = (double*) calloc(size, sizeof(double));
data->xtol = 1e-12;
data->maxfev = size*10000;
data->ml = size - 1;
data->mu = size - 1;
data->epsfcn = 1e-12;
data->diag = (double*) malloc(size*sizeof(double));
data->diagres = (double*) malloc(size*sizeof(double));
data->mode = 1;
data->factor = 100.0;
data->nprint = -1;
data->info = 0;
data->nfev = 0;
data->njev = 0;
data->fjac = (double*) calloc((size*size), sizeof(double));
data->fjacobian = (double*) calloc((size*size), sizeof(double));
data->ldfjac = size;
data->r__ = (double*) malloc(((size*(size+1))/2)*sizeof(double));
data->lr = (size*(size + 1)) / 2;
data->qtf = (double*) malloc(size*sizeof(double));
data->wa1 = (double*) malloc(size*sizeof(double));
data->wa2 = (double*) malloc(size*sizeof(double));
data->wa3 = (double*) malloc(size*sizeof(double));
data->wa4 = (double*) malloc(size*sizeof(double));
data->numberOfIterations = 0;
data->numberOfFunctionEvaluations = 0;
assertStreamPrint(NULL, 0 != *voiddata, "allocationHybrdData() voiddata failed!");
return 0;
}
/*! \fn allocate memory for mixed systems search solver
*
*/
int allocateMixedSearchData(int size, void** voiddata)
{
DATA_SEARCHMIXED_SOLVER* data = (DATA_SEARCHMIXED_SOLVER*) malloc(sizeof(DATA_SEARCHMIXED_SOLVER));
*voiddata = (void*)data;
assertStreamPrint(NULL, 0 != data, "allocationHybrdData() failed!");
data->iterationVars = (modelica_boolean*) malloc(size*sizeof(modelica_boolean));
data->iterationVars2 = (modelica_boolean*) malloc(size*sizeof(modelica_boolean));
data->iterationVarsPre = (modelica_boolean*) malloc(size*sizeof(modelica_boolean));
data->stateofSearch = (modelica_boolean*) malloc(size*sizeof(modelica_boolean));
assertStreamPrint(NULL, 0 != *voiddata, "allocateMixedSearchData() voiddata failed!");
return 0;
}
void listInsert(LIST *list, LIST_NODE* prevNode, const void *data)
{
LIST_NODE *tmpNode = (LIST_NODE*)malloc(sizeof(LIST_NODE));
assertStreamPrint(NULL, 0 != tmpNode, "out of memory");
tmpNode->data = malloc(list->itemSize);
assertStreamPrint(NULL, 0 != tmpNode->data, "out of memory");
memcpy(tmpNode->data, data, list->itemSize);
tmpNode->next = prevNode->next;
prevNode->next = tmpNode;
++(list->length);
if(list->last == prevNode)
list->last = tmpNode;
}
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);
}
/*! \fn allocate memory for linear system solver Klu
*
*/
int
allocateKluData(int n_row, int n_col, int nz, void** voiddata)
{
DATA_KLU* data = (DATA_KLU*) malloc(sizeof(DATA_KLU));
assertStreamPrint(NULL, 0 != data, "Could not allocate data for linear solver Klu.");
data->symbolic = NULL;
data->numeric = NULL;
data->n_col = n_col;
data->n_row = n_row;
data->nnz = nz;
data->Ap = (int*) calloc((n_row+1),sizeof(int));
data->Ai = (int*) calloc(nz,sizeof(int));
data->Ax = (double*) calloc(nz,sizeof(double));
data->work = (double*) calloc(n_col,sizeof(double));
data->numberSolving = 0;
klu_defaults(&(data->common));
*voiddata = (void*)data;
return 0;
}
void omc_csv_init(simulation_result *self, DATA *data)
{
int i;
const MODEL_DATA *mData = &(data->modelData);
const char* format = "\"%s\",";
FILE *fout = fopen(self->filename, "w");
assertStreamPrint(data->threadData, 0!=fout, "Error, couldn't create output file: [%s] because of %s", self->filename, strerror(errno));
fprintf(fout, format, "time");
if(self->cpuTime)
fprintf(fout, format, "$cpuTime");
for(i = 0; i < mData->nVariablesReal; i++) if(!mData->realVarsData[i].filterOutput)
fprintf(fout, format, mData->realVarsData[i].info.name);
for(i = 0; i < mData->nVariablesInteger; i++) if(!mData->integerVarsData[i].filterOutput)
fprintf(fout, format, mData->integerVarsData[i].info.name);
for(i = 0; i < mData->nVariablesBoolean; i++) if(!mData->booleanVarsData[i].filterOutput)
fprintf(fout, format, mData->booleanVarsData[i].info.name);
for(i = 0; i < mData->nVariablesString; i++) if(!mData->stringVarsData[i].filterOutput)
fprintf(fout, format, mData->stringVarsData[i].info.name);
for(i = 0; i < mData->nAliasReal; i++) if(!mData->realAlias[i].filterOutput && data->modelData.realAlias[i].aliasType != 1)
fprintf(fout, format, mData->realAlias[i].info.name);
for(i = 0; i < mData->nAliasInteger; i++) if(!mData->integerAlias[i].filterOutput && data->modelData.integerAlias[i].aliasType != 1)
fprintf(fout, format, mData->integerAlias[i].info.name);
for(i = 0; i < mData->nAliasBoolean; i++) if(!mData->booleanAlias[i].filterOutput && data->modelData.booleanAlias[i].aliasType != 1)
fprintf(fout, format, mData->booleanAlias[i].info.name);
for(i = 0; i < mData->nAliasString; i++) if(!mData->stringAlias[i].filterOutput && data->modelData.stringAlias[i].aliasType != 1)
fprintf(fout, format, mData->stringAlias[i].info.name);
fseek(fout, -1, SEEK_CUR); // removes the eol comma separator
fprintf(fout,"\n");
self->storage = fout;
}
/*! \fn allocate memory for linear system solver UmfPack
*
*/
int
allocateUmfPackData(int n_row, int n_col, int nz, void** voiddata)
{
DATA_UMFPACK* data = (DATA_UMFPACK*) malloc(sizeof(DATA_UMFPACK));
assertStreamPrint(NULL, 0 != data, "Could not allocate data for linear solver UmfPack.");
data->symbolic = NULL;
data->numeric = NULL;
data->n_col = n_col;
data->n_row = n_row;
data->nnz = nz;
data->Ap = (int*) calloc((n_row+1),sizeof(int));
data->Ai = (int*) calloc(nz,sizeof(int));
data->Ax = (double*) calloc(nz,sizeof(double));
data->work = (double*) calloc(n_col,sizeof(double));
data->numberSolving=0;
umfpack_di_defaults(data->control);
data->control[UMFPACK_PIVOT_TOLERANCE] = 0.1;
data->control[UMFPACK_IRSTEP] = 2;
data->control[UMFPACK_SCALE] = 1;
data->control[UMFPACK_STRATEGY] = 5;
*voiddata = (void*)data;
return 0;
}
long flattenStrBuf(int dims, const struct VAR_INFO** src, char* &dest, int& longest, int& nstrings, bool fixNames, bool useComment)
{
int i,len;
nstrings = dims;
longest = 0; /* the longest-string length */
/* calculate required size */
for(i = 0; i < dims; ++i) {
len = strlen(useComment ? src[i]->comment : src[i]->name);
if(len > longest) longest = len;
}
/* allocate memory */
dest = (char*) calloc(longest*nstrings+1, sizeof(char));
assertStreamPrint(NULL, 0!=dest,"Cannot allocate memory");
/* copy data */
char *ptr = dest;
/* for(i=0;i<dims;i++) {
len = strlen(useComment ? src[i]->comment : src[i]->name);
for(j = 0; j < len; ++j) {
strncpy(ptr + i + j*dims,useComment ? &src[i]->comment[j] : &src[i]->name[j],1);
}
} */
for(i = 0; i < dims; ++i) {
strncpy(ptr,useComment ? src[i]->comment : src[i]->name,longest+1 /* ensures that we get \0 after the longest string*/);
if(fixNames) fixDerInName(ptr,strlen(useComment ? src[i]->comment : src[i]->name));
ptr += longest;
}
/* return the size of the `dest' buffer */
return (longest*nstrings);
}
LIST_NODE *listNextNode(LIST_NODE *node)
{
assertStreamPrint(NULL, 0 != node, "invalid list-node");
if(node)
return node->next;
return NULL;
}
void listPushFront(LIST *list, const void *data)
{
LIST_NODE *tmpNode = NULL;
assertStreamPrint(NULL, 0 != list, "invalid list-pointer");
tmpNode = (LIST_NODE*)malloc(sizeof(LIST_NODE));
assertStreamPrint(NULL, 0 != tmpNode, "out of memory");
tmpNode->data = malloc(list->itemSize);
assertStreamPrint(NULL, 0 != tmpNode->data, "out of memory");
memcpy(tmpNode->data, data, list->itemSize);
tmpNode->next = list->first;
++(list->length);
list->first = tmpNode;
if(!list->last)
list->last = list->first;
}
static VAR_INFO* findVariable(const char *name)
{
hash_variable *s;
HASH_FIND_STR(variables, name, s);
if (0==s && 0!=strstr(name, "dummyVarStateSetJac")) {
static VAR_INFO dummyInfo = omc_dummyVarInfo;
return &dummyInfo;
}
assertStreamPrint(NULL, 0!=s, "Referenced '%s' that was not declared as <variable>", name);
return &s->var_info;
}
LIST *allocList(unsigned int itemSize)
{
LIST *list = (LIST*)malloc(sizeof(LIST));
assertStreamPrint(NULL, 0 != list, "out of memory");
list->first = NULL;
list->last = NULL;
list->itemSize = itemSize;
list->length = 0;
return list;
}
/*! \fn allocate memory for linear system solver lapack
*
*/
int allocateLapackData(int size, void** voiddata)
{
DATA_LAPACK* data = (DATA_LAPACK*) malloc(sizeof(DATA_LAPACK));
data->ipiv = (int*) malloc(size*sizeof(int));
assertStreamPrint(NULL, 0 != data->ipiv, "Could not allocate data for linear solver lapack.");
data->nrhs = 1;
data->info = 0;
data->work = _omc_allocateVectorData(size);
data->x = _omc_createVector(size, NULL);
data->b = _omc_createVector(size, NULL);
data->A = _omc_createMatrix(size, size, NULL);
*voiddata = (void*)data;
return 0;
}
void generateData_1(DATA *data, double* &data_1, int& rows, int& cols, double tstart, double tstop)
{
const SIMULATION_INFO *sInfo = &(data->simulationInfo);
const MODEL_DATA *mData = &(data->modelData);
int offset = 1;
long i = 0;
/* calculate number of rows and columns */
rows = 2;
cols = 1 + mData->nParametersReal +
mData->nParametersInteger +
mData->nParametersBoolean;
/* allocate data buffer */
data_1 = (double*)calloc(rows*cols, sizeof(double));
assertStreamPrint(data->threadData, 0!=data_1, "Malloc failed");
data_1[0] = tstart; /* start time */
data_1[cols] = tstop; /* stop time */
/* double variables */
for(i = 0; i < mData->nParametersReal; ++i)
{
data_1[offset+i] = sInfo->realParameter[i];
data_1[offset+i+cols] = sInfo->realParameter[i];
}
offset += mData->nParametersReal;
/* integer variables */
for(i = 0; i < mData->nParametersInteger; ++i)
{
data_1[offset+i] = (double)sInfo->integerParameter[i];
data_1[offset+i+cols] = (double)sInfo->integerParameter[i];
}
offset += mData->nParametersInteger;
/* bool variables */
for(i = 0; i < mData->nParametersBoolean; ++i)
{
data_1[offset+i] = (double)sInfo->booleanParameter[i];
data_1[offset+i+cols] = (double)sInfo->booleanParameter[i];
}
}
/*! \fn allocate memory for linear system solver Lis
*
*/
int
allocateLisData(int n_row, int n_col, int nz, void** voiddata)
{
DATA_LIS* data = (DATA_LIS*) malloc(sizeof(DATA_LIS));
char buffer[128];
assertStreamPrint(NULL, 0 != data, "Could not allocate data for linear solver Lis.");
data->n_col = n_col;
data->n_row = n_row;
data->nnz = nz;
lis_vector_create(LIS_COMM_WORLD, &(data->b));
lis_vector_set_size(data->b, data->n_row, 0);
lis_vector_create(LIS_COMM_WORLD, &(data->x));
lis_vector_set_size(data->x, data->n_row, 0);
lis_matrix_create(LIS_COMM_WORLD, &(data->A));
lis_matrix_set_size(data->A, data->n_row, 0);
lis_matrix_set_type(data->A, LIS_MATRIX_CSR);
lis_solver_create(&(data->solver));
lis_solver_set_option("-print none", data->solver);
sprintf(buffer,"-maxiter %d", n_row*100);
lis_solver_set_option(buffer, data->solver);
lis_solver_set_option("-scale none", data->solver);
lis_solver_set_option("-p none", data->solver);
lis_solver_set_option("-initx_zeros 0", data->solver);
lis_solver_set_option("-tol 1.0e-12", data->solver);
data->work = (double*) calloc(n_col,sizeof(double));
rt_ext_tp_tick(&(data->timeClock));
*voiddata = (void*)data;
return 0;
}
/*! \fn allocateNewtonData
* allocate memory for nonlinear system solver
*/
int allocateNewtonData(int size, void** voiddata)
{
DATA_NEWTON* data = (DATA_NEWTON*) malloc(sizeof(DATA_NEWTON));
*voiddata = (void*)data;
assertStreamPrint(NULL, NULL != data, "allocationNewtonData() failed!");
data->resScaling = (double*) malloc(size*sizeof(double));
data->fvecScaled = (double*) malloc(size*sizeof(double));
data->n = size;
data->x = (double*) malloc(size*sizeof(double));
data->fvec = (double*) calloc(size,sizeof(double));
data->xtol = 1e-6;
data->ftol = 1e-6;
data->maxfev = size*100;
data->epsfcn = DBL_EPSILON;
data->fjac = (double*) malloc((size*size)*sizeof(double));
data->rwork = (double*) malloc((size)*sizeof(double));
data->iwork = (int*) malloc(size*sizeof(int));
/* damped newton */
data->x_new = (double*) malloc(size*sizeof(double));
data->x_increment = (double*) malloc(size*sizeof(double));
data->f_old = (double*) calloc(size,sizeof(double));
data->fvec_minimum = (double*) calloc(size,sizeof(double));
data->delta_f = (double*) calloc(size,sizeof(double));
data->delta_x_vec = (double*) calloc(size,sizeof(double));
data->factorization = 0;
data->calculate_jacobian = 1;
data->numberOfIterations = 0;
data->numberOfFunctionEvaluations = 0;
return 0;
}
/*! \fn solve linear system with UmfPack method
*
* \param [in] [data]
* [sysNumber] index of the corresponding linear system
*
*
* author: kbalzereit, wbraun
*/
int
solveUmfPack(DATA *data, int sysNumber)
{
LINEAR_SYSTEM_DATA* systemData = &(data->simulationInfo.linearSystemData[sysNumber]);
DATA_UMFPACK* solverData = (DATA_UMFPACK*)systemData->solverData;
int i, j, status = UMFPACK_OK, success = 0, ni=0, n = systemData->size, eqSystemNumber = systemData->equationIndex, indexes[2] = {1,eqSystemNumber};
infoStreamPrintWithEquationIndexes(LOG_LS, 0, indexes, "Start solving Linear System %d (size %d) at time %g with UMFPACK Solver",
eqSystemNumber, (int) systemData->size,
data->localData[0]->timeValue);
rt_ext_tp_tick(&(solverData->timeClock));
if (0 == systemData->method)
{
/* set A matrix */
solverData->Ap[0] = 0;
systemData->setA(data, systemData);
solverData->Ap[solverData->n_row] = solverData->nnz;
if (ACTIVE_STREAM(LOG_LS_V))
{
infoStreamPrint(LOG_LS_V, 1, "Matrix A");
printMatrixCSR(solverData->Ap, solverData->Ai, solverData->Ax, n);
messageClose(LOG_LS_V);
}
/* set b vector */
systemData->setb(data, systemData);
} else {
solverData->Ap[0] = 0;
/* calculate jacobian -> matrix A*/
if(systemData->jacobianIndex != -1) {
getAnalyticalJacobianUmfPack(data, sysNumber);
} else {
assertStreamPrint(data->threadData, 1, "jacobian function pointer is invalid" );
}
solverData->Ap[solverData->n_row] = solverData->nnz;
/* calculate vector b (rhs) */
memcpy(solverData->work, systemData->x, sizeof(double)*solverData->n_row);
wrapper_fvec_umfpack(solverData->work, systemData->b, data, sysNumber);
}
infoStreamPrint(LOG_LS, 0, "### %f time to set Matrix A and vector b.", rt_ext_tp_tock(&(solverData->timeClock)));
if (ACTIVE_STREAM(LOG_LS_V))
{
if (ACTIVE_STREAM(LOG_LS_V))
{
infoStreamPrint(LOG_LS_V, 1, "Old solution x:");
for(i = 0; i < solverData->n_row; ++i)
infoStreamPrint(LOG_LS_V, 0, "[%d] %s = %g", i+1, modelInfoGetEquation(&data->modelData.modelDataXml,eqSystemNumber).vars[i], systemData->x[i]);
messageClose(LOG_LS_V);
}
infoStreamPrint(LOG_LS_V, 1, "Matrix A n_rows = %d", solverData->n_row);
for (i=0; i<solverData->n_row; i++) {
infoStreamPrint(LOG_LS_V, 0, "%d. Ap => %d -> %d", i, solverData->Ap[i], solverData->Ap[i+1]);
for (j=solverData->Ap[i]; j<solverData->Ap[i+1]; j++) {
infoStreamPrint(LOG_LS_V, 0, "A[%d,%d] = %f", i, solverData->Ai[j], solverData->Ax[j]);
}
}
messageClose(LOG_LS_V);
for (i=0; i<solverData->n_row; i++)
infoStreamPrint(LOG_LS_V, 0, "b[%d] = %e", i, systemData->b[i]);
}
rt_ext_tp_tick(&(solverData->timeClock));
/* symbolic pre-ordering of A to reduce fill-in of L and U */
if (0 == solverData->numberSolving)
{
status = umfpack_di_symbolic(solverData->n_col, solverData->n_row, solverData->Ap, solverData->Ai, solverData->Ax, &(solverData->symbolic), solverData->control, solverData->info);
}
/* compute the LU factorization of A */
if (0 == status) {
status = umfpack_di_numeric(solverData->Ap, solverData->Ai, solverData->Ax, solverData->symbolic, &(solverData->numeric), solverData->control, solverData->info);
}
if (0 == status) {
if (1 == systemData->method) {
status = umfpack_di_solve(UMFPACK_A, solverData->Ap, solverData->Ai, solverData->Ax, systemData->x, systemData->b, solverData->numeric, solverData->control, solverData->info);
} else {
status = umfpack_di_solve(UMFPACK_Aat, solverData->Ap, solverData->Ai, solverData->Ax, systemData->x, systemData->b, solverData->numeric, solverData->control, solverData->info);
}
}
if (status == UMFPACK_OK) {
success = 1;
}
else if (status == UMFPACK_WARNING_singular_matrix)
{
if (!solveSingularSystem(systemData))
{
success = 1;
}
}
infoStreamPrint(LOG_LS, 0, "Solve System: %f", rt_ext_tp_tock(&(solverData->timeClock)));
/* print solution */
if (1 == success) {
if (1 == systemData->method) {
/* take the solution */
for(i = 0; i < solverData->n_row; ++i)
systemData->x[i] += solverData->work[i];
/* update inner equations */
wrapper_fvec_umfpack(systemData->x, solverData->work, data, sysNumber);
} else {
/* the solution is automatically in x */
}
if (ACTIVE_STREAM(LOG_LS_V))
{
infoStreamPrint(LOG_LS_V, 1, "Solution x:");
infoStreamPrint(LOG_LS_V, 0, "System %d numVars %d.", eqSystemNumber, modelInfoGetEquation(&data->modelData.modelDataXml,eqSystemNumber).numVar);
for(i = 0; i < systemData->size; ++i)
infoStreamPrint(LOG_LS_V, 0, "[%d] %s = %g", i+1, modelInfoGetEquation(&data->modelData.modelDataXml,eqSystemNumber).vars[i], systemData->x[i]);
messageClose(LOG_LS_V);
}
}
else
{
warningStreamPrint(LOG_STDOUT, 0,
"Failed to solve linear system of equations (no. %d) at time %f, system status %d.",
(int)systemData->equationIndex, data->localData[0]->timeValue, status);
}
solverData->numberSolving += 1;
return success;
}
/**********************************************************************************************
* DASSL with synchronous treating of when equation
* - without integrated ZeroCrossing method.
* + ZeroCrossing are handled outside DASSL.
* + if no event occurs outside DASSL performs a warm-start
**********************************************************************************************/
int dassl_step(DATA* data, threadData_t *threadData, SOLVER_INFO* solverInfo)
{
TRACE_PUSH
double tout = 0;
int i = 0;
unsigned int ui = 0;
int retVal = 0;
int saveJumpState;
static unsigned int dasslStepsOutputCounter = 1;
DASSL_DATA *dasslData = (DASSL_DATA*) solverInfo->solverData;
SIMULATION_DATA *sData = data->localData[0];
SIMULATION_DATA *sDataOld = data->localData[1];
MODEL_DATA *mData = (MODEL_DATA*) data->modelData;
modelica_real* stateDer = dasslData->stateDer;
dasslData->rpar[0] = (double*) (void*) data;
dasslData->rpar[1] = (double*) (void*) dasslData;
dasslData->rpar[2] = (double*) (void*) threadData;
// printf("\tlastdesiredStep: %f\n", solverInfo->lastdesiredStep);
// printf("\tstateEvents: %d\n", solverInfo->stateEvents);
// printf("\tdidEventStep: %d\n", solverInfo->didEventStep);
// printf("\tsampleEvents: %d\n", solverInfo->sampleEvents);
// printf("\tintegratorSteps: %d\n", solverInfo->integratorSteps);
saveJumpState = threadData->currentErrorStage;
threadData->currentErrorStage = ERROR_INTEGRATOR;
/* try */
#if !defined(OMC_EMCC)
MMC_TRY_INTERNAL(simulationJumpBuffer)
#endif
assertStreamPrint(threadData, 0 != dasslData->rpar, "could not passed to DDASKR");
/* If an event is triggered and processed restart dassl. */
if(!dasslData->dasslAvoidEventRestart && (solverInfo->didEventStep || 0 == dasslData->idid))
{
debugStreamPrint(LOG_EVENTS_V, 0, "Event-management forced reset of DDASKR");
/* obtain reset */
dasslData->info[0] = 0;
dasslData->idid = 0;
memcpy(stateDer, data->localData[1]->realVars + data->modelData->nStates, sizeof(double)*data->modelData->nStates);
}
/* Calculate steps until TOUT is reached */
if (dasslData->dasslSteps)
{
/* If dasslsteps is selected, the dassl run to stopTime or next sample event */
if (data->simulationInfo->nextSampleEvent < data->simulationInfo->stopTime)
{
tout = data->simulationInfo->nextSampleEvent;
}
else
{
tout = data->simulationInfo->stopTime;
}
}
else
{
tout = solverInfo->currentTime + solverInfo->currentStepSize;
}
/* Check that tout is not less than timeValue
* else will dassl get in trouble. If that is the case we skip the current step. */
if (solverInfo->currentStepSize < DASSL_STEP_EPS)
{
infoStreamPrint(LOG_DASSL, 0, "Desired step to small try next one");
infoStreamPrint(LOG_DASSL, 0, "Interpolate linear");
/*euler step*/
for(i = 0; i < data->modelData->nStates; i++)
{
sData->realVars[i] = sDataOld->realVars[i] + stateDer[i] * solverInfo->currentStepSize;
}
sData->timeValue = solverInfo->currentTime + solverInfo->currentStepSize;
data->callback->functionODE(data, threadData);
solverInfo->currentTime = sData->timeValue;
TRACE_POP
return 0;
}
int dassl_initial(DATA* data, threadData_t *threadData, SOLVER_INFO* solverInfo, DASSL_DATA *dasslData)
{
TRACE_PUSH
/* work arrays for DASSL */
unsigned int i;
SIMULATION_DATA tmpSimData = {0};
RHSFinalFlag = 0;
dasslData->liw = 40 + data->modelData->nStates;
dasslData->lrw = 60 + ((maxOrder + 4) * data->modelData->nStates) + (data->modelData->nStates * data->modelData->nStates) + (3*data->modelData->nZeroCrossings);
dasslData->rwork = (double*) calloc(dasslData->lrw, sizeof(double));
assertStreamPrint(threadData, 0 != dasslData->rwork,"out of memory");
dasslData->iwork = (int*) calloc(dasslData->liw, sizeof(int));
assertStreamPrint(threadData, 0 != dasslData->iwork,"out of memory");
dasslData->ng = (int) data->modelData->nZeroCrossings;
dasslData->jroot = (int*) calloc(data->modelData->nZeroCrossings, sizeof(int));
dasslData->rpar = (double**) malloc(3*sizeof(double*));
dasslData->ipar = (int*) malloc(sizeof(int));
dasslData->ipar[0] = ACTIVE_STREAM(LOG_JAC);
assertStreamPrint(threadData, 0 != dasslData->ipar,"out of memory");
dasslData->atol = (double*) malloc(data->modelData->nStates*sizeof(double));
dasslData->rtol = (double*) malloc(data->modelData->nStates*sizeof(double));
dasslData->info = (int*) calloc(infoLength, sizeof(int));
assertStreamPrint(threadData, 0 != dasslData->info,"out of memory");
dasslData->dasslStatistics = (unsigned int*) calloc(numStatistics, sizeof(unsigned int));
assertStreamPrint(threadData, 0 != dasslData->dasslStatistics,"out of memory");
dasslData->dasslStatisticsTmp = (unsigned int*) calloc(numStatistics, sizeof(unsigned int));
assertStreamPrint(threadData, 0 != dasslData->dasslStatisticsTmp,"out of memory");
dasslData->idid = 0;
dasslData->sqrteps = sqrt(DBL_EPSILON);
dasslData->ysave = (double*) malloc(data->modelData->nStates*sizeof(double));
dasslData->delta_hh = (double*) malloc(data->modelData->nStates*sizeof(double));
dasslData->newdelta = (double*) malloc(data->modelData->nStates*sizeof(double));
dasslData->stateDer = (double*) malloc(data->modelData->nStates*sizeof(double));
data->simulationInfo->currentContext = CONTEXT_ALGEBRAIC;
/* ### start configuration of dassl ### */
infoStreamPrint(LOG_SOLVER, 1, "Configuration of the dassl code:");
printf("---------------###---------------\n\n");
printf("Some stats:\n\n");
printf("(A) Firstly, we consider some info of the object DATA *data:\n");
printf("(1) SIMULATION_INFO (*simulationInfo):\n");
printf("\tstartTime: %f\n", data->simulationInfo->startTime);
printf("\tstopTime: %f\n", data->simulationInfo->stopTime);
printf("\tnumSteps: %d\n", data->simulationInfo->numSteps);
printf("\ttolerance: %f\n", data->simulationInfo->tolerance);
printf("\ttolerance: %f\n", (*(*data).simulationInfo).tolerance);
printf("\t*solverMethod: %c\n", *(data->simulationInfo->solverMethod));
printf("\t*outputFormat: %c\n", *(data->simulationInfo->outputFormat));
printf("\t*variableFilter: %c\n", *(data->simulationInfo->variableFilter));
printf("\tlsMethod: %d\n", data->simulationInfo->lsMethod);
printf("\tmixedMethod: %d\n", data->simulationInfo->mixedMethod);
printf("\tnlsMethod: %d\n", data->simulationInfo->nlsMethod);
printf("\tnewtonStrategy: %d\n", data->simulationInfo->newtonStrategy);
printf("\tnlsCsvInfomation: %d\n", data->simulationInfo->nlsCsvInfomation);
printf("\tcurrentContext: %d\n", data->simulationInfo->currentContext);
printf("\tcurrentContextOld: %d\n", data->simulationInfo->currentContextOld);
printf("\tjacobianEvals: %d\n", data->simulationInfo->jacobianEvals);
printf("\tlambda: %d\n", data->simulationInfo->lambda);
printf("\tnextSampleEvent: %f\n", data->simulationInfo->nextSampleEvent);
printf("\tnextSampleTimes[0]: %f\n", data->simulationInfo->nextSampleTimes[0]);
printf("\tnextSampleTimes[1]: %f\n", data->simulationInfo->nextSampleTimes[1]);
printf("\tnextSampleTimes[2]: %f\n", data->simulationInfo->nextSampleTimes[2]);
printf("\n\tThere are even more although I believe they will not be useful for now.\n\n");
printf("(2) SIMULATION_DATA (**localData):\n");
printf("\ttimeValue: %f\n", data->localData[0]->timeValue);
printf("The following are the initial values.\n");
printf("\trealVars[0]: %f\n", data->localData[0]->realVars[0]);
printf("\trealVars[1]: %f\n", data->localData[0]->realVars[1]);
printf("\tintegerVars: %d\n", data->localData[0]->integerVars[1]);
printf("\t*booleanVars: %s\n", *(data->localData[0]->booleanVars));
printf("\t*stringVars: %s\n", *(data->localData[0]->stringVars));
//printf("\t*inlineVars: %f\n", *(data->localData[0]->inlineVars)); //Errors when attempting to print this one. Not sure why though.
printf("\n\tI am not sure this garbage struct is necessary. One \'timeValue\' is used. I am sure we can use a local variable or a similar route.\n\n");
printf("(3) MODEL_DATA (*modelData):\n");
printf("\trealVarsData[0].attribute.nominal: %f\n", data->modelData->realVarsData[0].attribute.nominal);
printf("\trealVarsData[1].attribute.nominal: %f\n", data->modelData->realVarsData[1].attribute.nominal);
printf("\trealVarsData[0].attribute.useStart: %s\n", data->modelData->realVarsData[0].attribute.useStart ? "true" : "false");
printf("\trealVarsData[1].attribute.useStart: %s\n", data->modelData->realVarsData[1].attribute.useStart ? "true" : "false");
printf("\tnStates: %d\n", data->modelData->nStates);
printf("\tnVariablesReal: %d\n", data->modelData->nVariablesReal);
printf("\tnDiscreteReal: %d\n", data->modelData->nDiscreteReal);
printf("\tnVariablesInteger: %d\n", data->modelData->nVariablesInteger);
printf("\tnVariablesBoolean: %d\n", data->modelData->nVariablesBoolean);
printf("\tnVariablesString: %d\n", data->modelData->nVariablesString);
printf("\tnParametersReal: %d\n", data->modelData->nParametersReal);
printf("\tnVariablesReal: %d\n", data->modelData->nVariablesReal);
printf("\tnParametersInteger: %d\n", data->modelData->nParametersInteger);
printf("\tnParametersBoolean: %d\n", data->modelData->nParametersBoolean);
printf("\tnParametersString: %d\n", data->modelData->nParametersString);
printf("\tnInputVars: %d\n", data->modelData->nInputVars);
printf("\tnOutputVars: %d\n", data->modelData->nOutputVars);
printf("\tnZeroCrossings: %d\n", data->modelData->nZeroCrossings);
printf("\tnMathEvents: %d\n", data->modelData->nMathEvents);
printf("\tnDelayExpressions: %d\n", data->modelData->nDelayExpressions);
printf("\tnExtObjs: %d\n", data->modelData->nExtObjs);
printf("\tnMixedSystems: %d\n", data->modelData->nMixedSystems);
printf("\tnLinearSystems: %d\n", data->modelData->nLinearSystems);
printf("\tnNonLinearSystems: %d\n", data->modelData->nNonLinearSystems);
printf("\tnStateSets: %d\n", data->modelData->nStateSets);
printf("\tnInlineVars: %d\n", data->modelData->nInlineVars);
printf("\tnOptimizeConstraints: %d\n", data->modelData->nOptimizeConstraints);
printf("\tnOptimizeFinalConstraints: %d\n\n", data->modelData->nOptimizeFinalConstraints);
printf("(4) RINGBUFFER* (simulationData) -- The first comment in the .c file is that this does not work. This struct is never used in the qss solver.\n\n");
//printf("\titemSize: %d\n", data->simulationData->itemSize);
printf("(5) OpenModelicaGeneratedFunctionCallbacks (*callback). Just a number of functions updating the results. Not even sure where all these functions are defined. We may want to investigate where these functions are defined if we want to have a full understanding of the how OpenModelica enables it's solvers.\n\n");
printf("(B) threadData_t threadData. Next we have to consider the object threadData_t. However, I cannot find the definition of this object. Must investigate and get all attributes.\n\n");
printf("(C) SOLVER_INFO solverInfo:\n");
printf("\tcurrentTime: %f\n", solverInfo->currentTime);
printf("\tcurrentStepSize: %f\n", solverInfo->currentStepSize);
printf("\tlaststep: %f\n", solverInfo->laststep);
printf("\tsolverMethod: %d\n", solverInfo->solverMethod);
printf("\tsolverStepSize: %f\n", solverInfo->solverStepSize);
printf("\tsolverRootFinding: %s\n", solverInfo->solverRootFinding ? "true" : "false");
printf("\tsolverNoEquidistantGrid: %s\n", solverInfo->solverNoEquidistantGrid ? "true" : "false");
printf("\tlastdesiredStep: %f\n", solverInfo->lastdesiredStep);
printf("\tstateEvents: %d\n", solverInfo->stateEvents);
printf("\tdidEventStep: %d\n", solverInfo->didEventStep);
// printf("\teventLst.itemSize %d\n", solverInfo->eventLst->itemSize);
// printf("\teventLst.length %d\n", solverInfo->eventLst.length);
printf("\tsampleEvents: %d\n", solverInfo->sampleEvents);
printf("\tintegratorSteps: %d\n", solverInfo->integratorSteps);
printf("---------------###---------------\n\n");
/* set nominal values of the states for absolute tolerances */
dasslData->info[1] = 1;
infoStreamPrint(LOG_SOLVER, 1, "The relative tolerance is %g. Following absolute tolerances are used for the states: ", data->simulationInfo->tolerance);
for(i=0; i<data->modelData->nStates; ++i)
{
dasslData->rtol[i] = data->simulationInfo->tolerance;
dasslData->atol[i] = data->simulationInfo->tolerance * fmax(fabs(data->modelData->realVarsData[i].attribute.nominal), 1e-32);
infoStreamPrint(LOG_SOLVER, 0, "%d. %s -> %g", i+1, data->modelData->realVarsData[i].info.name, dasslData->atol[i]);
}
messageClose(LOG_SOLVER);
/* let dassl return at every internal step */
dasslData->info[2] = 1;
/* define maximum step size, which is dassl is allowed to go */
if (omc_flag[FLAG_MAX_STEP_SIZE])
{
double maxStepSize = atof(omc_flagValue[FLAG_MAX_STEP_SIZE]);
assertStreamPrint(threadData, maxStepSize >= DASSL_STEP_EPS, "Selected maximum step size %e is too small.", maxStepSize);
dasslData->rwork[1] = maxStepSize;
dasslData->info[6] = 1;
infoStreamPrint(LOG_SOLVER, 0, "maximum step size %g", dasslData->rwork[1]);
}
else
{
infoStreamPrint(LOG_SOLVER, 0, "maximum step size not set");
}
/* define initial step size, which is dassl is used every time it restarts */
if (omc_flag[FLAG_INITIAL_STEP_SIZE])
{
double initialStepSize = atof(omc_flagValue[FLAG_INITIAL_STEP_SIZE]);
assertStreamPrint(threadData, initialStepSize >= DASSL_STEP_EPS, "Selected initial step size %e is too small.", initialStepSize);
dasslData->rwork[2] = initialStepSize;
dasslData->info[7] = 1;
infoStreamPrint(LOG_SOLVER, 0, "initial step size %g", dasslData->rwork[2]);
}
else
{
infoStreamPrint(LOG_SOLVER, 0, "initial step size not set");
}
/* define maximum integration order of dassl */
if (omc_flag[FLAG_MAX_ORDER])
{
int maxOrder = atoi(omc_flagValue[FLAG_MAX_ORDER]);
assertStreamPrint(threadData, maxOrder >= 1 && maxOrder <= 5, "Selected maximum order %d is out of range (1-5).", maxOrder);
dasslData->iwork[2] = maxOrder;
dasslData->info[8] = 1;
}
infoStreamPrint(LOG_SOLVER, 0, "maximum integration order %d", dasslData->info[8]?dasslData->iwork[2]:maxOrder);
/* if FLAG_NOEQUIDISTANT_GRID is set, choose dassl step method */
if (omc_flag[FLAG_NOEQUIDISTANT_GRID])
{
dasslData->dasslSteps = 1; /* TRUE */
solverInfo->solverNoEquidistantGrid = 1;
}
else
{
dasslData->dasslSteps = 0; /* FALSE */
}
infoStreamPrint(LOG_SOLVER, 0, "use equidistant time grid %s", dasslData->dasslSteps?"NO":"YES");
/* check if Flags FLAG_NOEQUIDISTANT_OUT_FREQ or FLAG_NOEQUIDISTANT_OUT_TIME are set */
if (dasslData->dasslSteps){
if (omc_flag[FLAG_NOEQUIDISTANT_OUT_FREQ])
{
dasslData->dasslStepsFreq = atoi(omc_flagValue[FLAG_NOEQUIDISTANT_OUT_FREQ]);
}
else if (omc_flag[FLAG_NOEQUIDISTANT_OUT_TIME])
{
dasslData->dasslStepsTime = atof(omc_flagValue[FLAG_NOEQUIDISTANT_OUT_TIME]);
dasslData->rwork[1] = dasslData->dasslStepsTime;
dasslData->info[6] = 1;
infoStreamPrint(LOG_SOLVER, 0, "maximum step size %g", dasslData->rwork[1]);
} else {
dasslData->dasslStepsFreq = 1;
dasslData->dasslStepsTime = 0.0;
}
if (omc_flag[FLAG_NOEQUIDISTANT_OUT_FREQ] && omc_flag[FLAG_NOEQUIDISTANT_OUT_TIME]){
warningStreamPrint(LOG_STDOUT, 0, "The flags are \"noEquidistantOutputFrequency\" "
"and \"noEquidistantOutputTime\" are in opposition "
"to each other. The flag \"noEquidistantOutputFrequency\" superiors.");
}
infoStreamPrint(LOG_SOLVER, 0, "as the output frequency control is used: %d", dasslData->dasslStepsFreq);
infoStreamPrint(LOG_SOLVER, 0, "as the output frequency time step control is used: %f", dasslData->dasslStepsTime);
}
/* if FLAG_DASSL_JACOBIAN is set, choose dassl jacobian calculation method */
if (omc_flag[FLAG_DASSL_JACOBIAN])
{
for(i=1; i< DASSL_JAC_MAX;i++)
{
if(!strcmp((const char*)omc_flagValue[FLAG_DASSL_JACOBIAN], dasslJacobianMethodStr[i])){
dasslData->dasslJacobian = (int)i;
break;
}
}
if(dasslData->dasslJacobian == DASSL_JAC_UNKNOWN)
{
if (ACTIVE_WARNING_STREAM(LOG_SOLVER))
{
warningStreamPrint(LOG_SOLVER, 1, "unrecognized jacobian calculation method %s, current options are:", (const char*)omc_flagValue[FLAG_DASSL_JACOBIAN]);
for(i=1; i < DASSL_JAC_MAX; ++i)
{
warningStreamPrint(LOG_SOLVER, 0, "%-15s [%s]", dasslJacobianMethodStr[i], dasslJacobianMethodDescStr[i]);
}
messageClose(LOG_SOLVER);
}
throwStreamPrint(threadData,"unrecognized jacobian calculation method %s", (const char*)omc_flagValue[FLAG_DASSL_JACOBIAN]);
}
/* default case colored numerical jacobian */
}
else
{
dasslData->dasslJacobian = DASSL_COLOREDNUMJAC;
}
/* selects the calculation method of the jacobian */
if(dasslData->dasslJacobian == DASSL_COLOREDNUMJAC ||
dasslData->dasslJacobian == DASSL_COLOREDSYMJAC ||
dasslData->dasslJacobian == DASSL_SYMJAC)
{
if (data->callback->initialAnalyticJacobianA(data, threadData))
{
infoStreamPrint(LOG_STDOUT, 0, "Jacobian or SparsePattern is not generated or failed to initialize! Switch back to normal.");
dasslData->dasslJacobian = DASSL_INTERNALNUMJAC;
}
}
/* default use a user sub-routine for JAC */
dasslData->info[4] = 1;
/* set up the appropriate function pointer */
switch (dasslData->dasslJacobian){
case DASSL_COLOREDNUMJAC:
data->simulationInfo->jacobianEvals = data->simulationInfo->analyticJacobians[data->callback->INDEX_JAC_A].sparsePattern.maxColors;
dasslData->jacobianFunction = JacobianOwnNumColored;
break;
case DASSL_COLOREDSYMJAC:
data->simulationInfo->jacobianEvals = data->simulationInfo->analyticJacobians[data->callback->INDEX_JAC_A].sparsePattern.maxColors;
dasslData->jacobianFunction = JacobianSymbolicColored;
break;
case DASSL_SYMJAC:
dasslData->jacobianFunction = JacobianSymbolic;
break;
case DASSL_NUMJAC:
dasslData->jacobianFunction = JacobianOwnNum;
break;
case DASSL_INTERNALNUMJAC:
dasslData->jacobianFunction = dummy_Jacobian;
/* no user sub-routine for JAC */
dasslData->info[4] = 0;
break;
default:
throwStreamPrint(threadData,"unrecognized jacobian calculation method %s", (const char*)omc_flagValue[FLAG_DASSL_JACOBIAN]);
break;
}
infoStreamPrint(LOG_SOLVER, 0, "jacobian is calculated by %s", dasslJacobianMethodDescStr[dasslData->dasslJacobian]);
/* if FLAG_DASSL_NO_ROOTFINDING is set, choose dassl with out internal root finding */
if(omc_flag[FLAG_DASSL_NO_ROOTFINDING])
{
dasslData->dasslRootFinding = 0;
dasslData->zeroCrossingFunction = dummy_zeroCrossing;
dasslData->ng = 0;
}
else
{
solverInfo->solverRootFinding = 1;
dasslData->dasslRootFinding = 1;
dasslData->zeroCrossingFunction = function_ZeroCrossingsDASSL;
}
infoStreamPrint(LOG_SOLVER, 0, "dassl uses internal root finding method %s", dasslData->dasslRootFinding?"YES":"NO");
/* if FLAG_DASSL_NO_RESTART is set, choose dassl step method */
if (omc_flag[FLAG_DASSL_NO_RESTART])
{
dasslData->dasslAvoidEventRestart = 1; /* TRUE */
}
else
{
dasslData->dasslAvoidEventRestart = 0; /* FALSE */
}
infoStreamPrint(LOG_SOLVER, 0, "dassl performs an restart after an event occurs %s", dasslData->dasslAvoidEventRestart?"NO":"YES");
/* ### end configuration of dassl ### */
messageClose(LOG_SOLVER);
TRACE_POP
return 0;
}
/*! \fn solve linear system with Klu method
*
* \param [in] [data]
* [sysNumber] index of the corresponding linear system
*
*
* author: wbraun
*/
int
solveKlu(DATA *data, threadData_t *threadData, int sysNumber)
{
void *dataAndThreadData[2] = {data, threadData};
LINEAR_SYSTEM_DATA* systemData = &(data->simulationInfo->linearSystemData[sysNumber]);
DATA_KLU* solverData = (DATA_KLU*)systemData->solverData;
int i, j, status = 0, success = 0, n = systemData->size, eqSystemNumber = systemData->equationIndex, indexes[2] = {1,eqSystemNumber};
infoStreamPrintWithEquationIndexes(LOG_LS, 0, indexes, "Start solving Linear System %d (size %d) at time %g with Klu Solver",
eqSystemNumber, (int) systemData->size,
data->localData[0]->timeValue);
rt_ext_tp_tick(&(solverData->timeClock));
if (0 == systemData->method)
{
/* set A matrix */
solverData->Ap[0] = 0;
systemData->setA(data, threadData, systemData);
solverData->Ap[solverData->n_row] = solverData->nnz;
if (ACTIVE_STREAM(LOG_LS_V))
{
infoStreamPrint(LOG_LS_V, 1, "Matrix A");
printMatrixCSR(solverData->Ap, solverData->Ai, solverData->Ax, n);
messageClose(LOG_LS_V);
}
/* set b vector */
systemData->setb(data, threadData, systemData);
} else {
solverData->Ap[0] = 0;
/* calculate jacobian -> matrix A*/
if(systemData->jacobianIndex != -1){
getAnalyticalJacobian(data, threadData, sysNumber);
} else {
assertStreamPrint(threadData, 1, "jacobian function pointer is invalid" );
}
solverData->Ap[solverData->n_row] = solverData->nnz;
/* calculate vector b (rhs) */
memcpy(solverData->work, systemData->x, sizeof(double)*solverData->n_row);
residual_wrapper(solverData->work, systemData->b, dataAndThreadData, sysNumber);
}
infoStreamPrint(LOG_LS, 0, "### %f time to set Matrix A and vector b.", rt_ext_tp_tock(&(solverData->timeClock)));
if (ACTIVE_STREAM(LOG_LS_V))
{
if (ACTIVE_STREAM(LOG_LS_V))
{
infoStreamPrint(LOG_LS_V, 1, "Old solution x:");
for(i = 0; i < solverData->n_row; ++i)
infoStreamPrint(LOG_LS_V, 0, "[%d] %s = %g", i+1, modelInfoGetEquation(&data->modelData->modelDataXml,eqSystemNumber).vars[i], systemData->x[i]);
messageClose(LOG_LS_V);
}
infoStreamPrint(LOG_LS_V, 1, "Matrix A n_rows = %d", solverData->n_row);
for (i=0; i<solverData->n_row; i++){
infoStreamPrint(LOG_LS_V, 0, "%d. Ap => %d -> %d", i, solverData->Ap[i], solverData->Ap[i+1]);
for (j=solverData->Ap[i]; j<solverData->Ap[i+1]; j++){
infoStreamPrint(LOG_LS_V, 0, "A[%d,%d] = %f", i, solverData->Ai[j], solverData->Ax[j]);
}
}
messageClose(LOG_LS_V);
for (i=0; i<solverData->n_row; i++)
infoStreamPrint(LOG_LS_V, 0, "b[%d] = %e", i, systemData->b[i]);
}
rt_ext_tp_tick(&(solverData->timeClock));
/* symbolic pre-ordering of A to reduce fill-in of L and U */
if (0 == solverData->numberSolving)
{
infoStreamPrint(LOG_LS_V, 0, "Perform analyze settings:\n - ordering used: %d\n - current status: %d", solverData->common.ordering, solverData->common.status);
solverData->symbolic = klu_analyze(solverData->n_col, solverData->Ap, solverData->Ai, &solverData->common);
}
/* compute the LU factorization of A */
if (0 == solverData->common.status){
solverData->numeric = klu_factor(solverData->Ap, solverData->Ai, solverData->Ax, solverData->symbolic, &solverData->common);
}
if (0 == solverData->common.status){
if (1 == systemData->method){
if (klu_solve(solverData->symbolic, solverData->numeric, solverData->n_col, 1, systemData->b, &solverData->common)){
success = 1;
}
} else {
if (klu_tsolve(solverData->symbolic, solverData->numeric, solverData->n_col, 1, systemData->b, &solverData->common)){
success = 1;
}
}
}
infoStreamPrint(LOG_LS, 0, "Solve System: %f", rt_ext_tp_tock(&(solverData->timeClock)));
/* print solution */
if (1 == success){
if (1 == systemData->method){
/* take the solution */
for(i = 0; i < solverData->n_row; ++i)
systemData->x[i] += systemData->b[i];
/* update inner equations */
residual_wrapper(systemData->x, solverData->work, dataAndThreadData, sysNumber);
} else {
/* the solution is automatically in x */
memcpy(systemData->x, systemData->b, sizeof(double)*systemData->size);
}
if (ACTIVE_STREAM(LOG_LS_V))
{
infoStreamPrint(LOG_LS_V, 1, "Solution x:");
infoStreamPrint(LOG_LS_V, 0, "System %d numVars %d.", eqSystemNumber, modelInfoGetEquation(&data->modelData->modelDataXml,eqSystemNumber).numVar);
for(i = 0; i < systemData->size; ++i)
infoStreamPrint(LOG_LS_V, 0, "[%d] %s = %g", i+1, modelInfoGetEquation(&data->modelData->modelDataXml,eqSystemNumber).vars[i], systemData->x[i]);
messageClose(LOG_LS_V);
}
}
else
{
warningStreamPrint(LOG_STDOUT, 0,
"Failed to solve linear system of equations (no. %d) at time %f, system status %d.",
(int)systemData->equationIndex, data->localData[0]->timeValue, status);
}
solverData->numberSolving += 1;
return success;
}
void *listNodeData(LIST_NODE *node)
{
assertStreamPrint(NULL, 0 != node, "invalid list-node");
assertStreamPrint(NULL, 0 != node->data, "invalid data node");
return node->data;
}
int checkCommandLineArguments(int argc, char **argv)
{
int i,j;
/* This works not that well - but is probably better than no check */
assertStreamPrint(NULL, !strcmp(FLAG_NAME[FLAG_MAX], "FLAG_MAX"), "unbalanced command line flag structure: FLAG_NAME");
assertStreamPrint(NULL, !strcmp(FLAG_DESC[FLAG_MAX], "FLAG_MAX"), "unbalanced command line flag structure: FLAG_DESC");
assertStreamPrint(NULL, !strcmp(FLAG_DETAILED_DESC[FLAG_MAX], "FLAG_MAX"), "unbalanced command line flag structure: FLAG_DETAILED_DESC");
for(i=0; i<FLAG_MAX; ++i)
{
omc_flag[i] = 0;
omc_flagValue[i] = NULL;
}
#ifdef USE_DEBUG_OUTPUT
debugStreamPrint(LOG_STDOUT, 1, "used command line options");
for(i=1; i<argc; ++i)
debugStreamPrint(LOG_STDOUT, 0, "%s", argv[i]);
messageClose(LOG_STDOUT);
debugStreamPrint(LOG_STDOUT, 1, "interpreted command line options");
#endif
for(i=1; i<argc; ++i)
{
int found=0;
for(j=1; j<FLAG_MAX; ++j)
{
if((FLAG_TYPE[j] == FLAG_TYPE_FLAG) && flagSet(FLAG_NAME[j], 1, argv+i))
{
if(omc_flag[j]) {
warningStreamPrint(LOG_STDOUT, 0, "each command line option can only be used once: %s", argv[i]);
return 1;
}
omc_flag[j] = 1;
found=1;
#ifdef USE_DEBUG_OUTPUT
debugStreamPrint(LOG_STDOUT, 0, "-%s", FLAG_NAME[j]);
#endif
break;
} else if((FLAG_TYPE[j] == FLAG_TYPE_OPTION) && flagSet(FLAG_NAME[j], 1, argv+i) && (i+1 < argc)) {
if(omc_flag[j]) {
warningStreamPrint(LOG_STDOUT, 0, "each command line option can only be used once: %s", argv[i]);
return 1;
}
omc_flag[j] = 1;
omc_flagValue[j] = (char*)getFlagValue(FLAG_NAME[j], 1, argv+i);
i++;
found=1;
#ifdef USE_DEBUG_OUTPUT
debugStreamPrint(LOG_STDOUT, 0, "-%s %s", FLAG_NAME[j], omc_flagValue[j]);
#endif
break;
} else if((FLAG_TYPE[j] == FLAG_TYPE_OPTION) && optionSet(FLAG_NAME[j], 1, argv+i)) {
if(omc_flag[j]) {
warningStreamPrint(LOG_STDOUT, 0, "each command line option can only be used once: %s", argv[i]);
return 1;
}
omc_flag[j] = 1;
omc_flagValue[j] = (char*)getOption(FLAG_NAME[j], 1, argv+i);
found=1;
#ifdef USE_DEBUG_OUTPUT
debugStreamPrint(LOG_STDOUT, 0, "-%s=%s", FLAG_NAME[j], omc_flagValue[j]);
#endif
break;
}
}
if(!found)
{
#ifdef USE_DEBUG_OUTPUT
messageClose(LOG_STDOUT);
#endif
warningStreamPrint(LOG_STDOUT, 0, "invalid command line option: %s", argv[i]);
return 1;
}
}
#ifdef USE_DEBUG_OUTPUT
messageClose(LOG_STDOUT);
#endif
return 0;
}
int dassl_initial(DATA* data, threadData_t *threadData, SOLVER_INFO* solverInfo, DASSL_DATA *dasslData)
{
TRACE_PUSH
/* work arrays for DASSL */
unsigned int i;
SIMULATION_DATA tmpSimData = {0};
RHSFinalFlag = 0;
dasslData->liw = 40 + data->modelData.nStates;
dasslData->lrw = 60 + ((maxOrder + 4) * data->modelData.nStates) + (data->modelData.nStates * data->modelData.nStates) + (3*data->modelData.nZeroCrossings);
dasslData->rwork = (double*) calloc(dasslData->lrw, sizeof(double));
assertStreamPrint(threadData, 0 != dasslData->rwork,"out of memory");
dasslData->iwork = (int*) calloc(dasslData->liw, sizeof(int));
assertStreamPrint(threadData, 0 != dasslData->iwork,"out of memory");
dasslData->ng = (int) data->modelData.nZeroCrossings;
dasslData->jroot = (int*) calloc(data->modelData.nZeroCrossings, sizeof(int));
dasslData->rpar = (double**) malloc(3*sizeof(double*));
dasslData->ipar = (int*) malloc(sizeof(int));
dasslData->ipar[0] = ACTIVE_STREAM(LOG_JAC);
assertStreamPrint(threadData, 0 != dasslData->ipar,"out of memory");
dasslData->atol = (double*) malloc(data->modelData.nStates*sizeof(double));
dasslData->rtol = (double*) malloc(data->modelData.nStates*sizeof(double));
dasslData->info = (int*) calloc(infoLength, sizeof(int));
assertStreamPrint(threadData, 0 != dasslData->info,"out of memory");
dasslData->dasslStatistics = (unsigned int*) calloc(numStatistics, sizeof(unsigned int));
assertStreamPrint(threadData, 0 != dasslData->dasslStatistics,"out of memory");
dasslData->dasslStatisticsTmp = (unsigned int*) calloc(numStatistics, sizeof(unsigned int));
assertStreamPrint(threadData, 0 != dasslData->dasslStatisticsTmp,"out of memory");
dasslData->idid = 0;
dasslData->sqrteps = sqrt(DBL_EPSILON);
dasslData->ysave = (double*) malloc(data->modelData.nStates*sizeof(double));
dasslData->delta_hh = (double*) malloc(data->modelData.nStates*sizeof(double));
dasslData->newdelta = (double*) malloc(data->modelData.nStates*sizeof(double));
dasslData->stateDer = (double*) malloc(data->modelData.nStates*sizeof(double));
dasslData->currentContext = CONTEXT_UNKNOWN;
/* setup internal ring buffer for dassl */
/* RingBuffer */
dasslData->simulationData = 0;
dasslData->simulationData = allocRingBuffer(SIZERINGBUFFER, sizeof(SIMULATION_DATA));
if(!data->simulationData)
{
throwStreamPrint(threadData, "Your memory is not strong enough for our Ringbuffer!");
}
/* prepare RingBuffer */
for(i=0; i<SIZERINGBUFFER; i++)
{
/* set time value */
tmpSimData.timeValue = 0;
/* buffer for all variable values */
tmpSimData.realVars = (modelica_real*)calloc(data->modelData.nVariablesReal, sizeof(modelica_real));
assertStreamPrint(threadData, 0 != tmpSimData.realVars, "out of memory");
tmpSimData.integerVars = (modelica_integer*)calloc(data->modelData.nVariablesInteger, sizeof(modelica_integer));
assertStreamPrint(threadData, 0 != tmpSimData.integerVars, "out of memory");
tmpSimData.booleanVars = (modelica_boolean*)calloc(data->modelData.nVariablesBoolean, sizeof(modelica_boolean));
assertStreamPrint(threadData, 0 != tmpSimData.booleanVars, "out of memory");
tmpSimData.stringVars = (modelica_string*) GC_malloc_uncollectable(data->modelData.nVariablesString * sizeof(modelica_string));
assertStreamPrint(threadData, 0 != tmpSimData.stringVars, "out of memory");
appendRingData(dasslData->simulationData, &tmpSimData);
}
dasslData->localData = (SIMULATION_DATA**) GC_malloc_uncollectable(SIZERINGBUFFER * sizeof(SIMULATION_DATA));
memset(dasslData->localData, 0, SIZERINGBUFFER * sizeof(SIMULATION_DATA));
rotateRingBuffer(dasslData->simulationData, 0, (void**) dasslData->localData);
/* end setup internal ring buffer for dassl */
/* ### start configuration of dassl ### */
infoStreamPrint(LOG_SOLVER, 1, "Configuration of the dassl code:");
/* set nominal values of the states for absolute tolerances */
dasslData->info[1] = 1;
infoStreamPrint(LOG_SOLVER, 1, "The relative tolerance is %g. Following absolute tolerances are used for the states: ", data->simulationInfo.tolerance);
for(i=0; i<data->modelData.nStates; ++i)
{
dasslData->rtol[i] = data->simulationInfo.tolerance;
dasslData->atol[i] = data->simulationInfo.tolerance * fmax(fabs(data->modelData.realVarsData[i].attribute.nominal), 1e-32);
infoStreamPrint(LOG_SOLVER, 0, "%d. %s -> %g", i+1, data->modelData.realVarsData[i].info.name, dasslData->atol[i]);
}
messageClose(LOG_SOLVER);
/* let dassl return at every internal step */
dasslData->info[2] = 1;
/* define maximum step size, which is dassl is allowed to go */
if (omc_flag[FLAG_MAX_STEP_SIZE])
{
double maxStepSize = atof(omc_flagValue[FLAG_MAX_STEP_SIZE]);
assertStreamPrint(threadData, maxStepSize >= DASSL_STEP_EPS, "Selected maximum step size %e is too small.", maxStepSize);
dasslData->rwork[1] = maxStepSize;
dasslData->info[6] = 1;
infoStreamPrint(LOG_SOLVER, 0, "maximum step size %g", dasslData->rwork[1]);
}
else
{
infoStreamPrint(LOG_SOLVER, 0, "maximum step size not set");
}
/* define initial step size, which is dassl is used every time it restarts */
if (omc_flag[FLAG_INITIAL_STEP_SIZE])
{
double initialStepSize = atof(omc_flagValue[FLAG_INITIAL_STEP_SIZE]);
assertStreamPrint(threadData, initialStepSize >= DASSL_STEP_EPS, "Selected initial step size %e is too small.", initialStepSize);
dasslData->rwork[2] = initialStepSize;
dasslData->info[7] = 1;
infoStreamPrint(LOG_SOLVER, 0, "initial step size %g", dasslData->rwork[2]);
}
else
{
infoStreamPrint(LOG_SOLVER, 0, "initial step size not set");
}
/* define maximum integration order of dassl */
if (omc_flag[FLAG_MAX_ORDER])
{
int maxOrder = atoi(omc_flagValue[FLAG_MAX_ORDER]);
assertStreamPrint(threadData, maxOrder >= 1 && maxOrder <= 5, "Selected maximum order %d is out of range (1-5).", maxOrder);
dasslData->iwork[2] = maxOrder;
dasslData->info[8] = 1;
}
infoStreamPrint(LOG_SOLVER, 0, "maximum integration order %d", dasslData->info[8]?dasslData->iwork[2]:maxOrder);
/* if FLAG_NOEQUIDISTANT_GRID is set, choose dassl step method */
if (omc_flag[FLAG_NOEQUIDISTANT_GRID])
{
dasslData->dasslSteps = 1; /* TRUE */
solverInfo->solverNoEquidistantGrid = 1;
}
else
{
dasslData->dasslSteps = 0; /* FALSE */
}
infoStreamPrint(LOG_SOLVER, 0, "use equidistant time grid %s", dasslData->dasslSteps?"NO":"YES");
/* check if Flags FLAG_NOEQUIDISTANT_OUT_FREQ or FLAG_NOEQUIDISTANT_OUT_TIME are set */
if (dasslData->dasslSteps){
if (omc_flag[FLAG_NOEQUIDISTANT_OUT_FREQ])
{
dasslData->dasslStepsFreq = atoi(omc_flagValue[FLAG_NOEQUIDISTANT_OUT_FREQ]);
}
else if (omc_flag[FLAG_NOEQUIDISTANT_OUT_TIME])
{
dasslData->dasslStepsTime = atof(omc_flagValue[FLAG_NOEQUIDISTANT_OUT_TIME]);
dasslData->rwork[1] = dasslData->dasslStepsTime;
dasslData->info[6] = 1;
infoStreamPrint(LOG_SOLVER, 0, "maximum step size %g", dasslData->rwork[1]);
} else {
dasslData->dasslStepsFreq = 1;
dasslData->dasslStepsTime = 0.0;
}
if (omc_flag[FLAG_NOEQUIDISTANT_OUT_FREQ] && omc_flag[FLAG_NOEQUIDISTANT_OUT_TIME]){
warningStreamPrint(LOG_STDOUT, 0, "The flags are \"noEquidistantOutputFrequency\" "
"and \"noEquidistantOutputTime\" are in opposition "
"to each other. The flag \"noEquidistantOutputFrequency\" superiors.");
}
infoStreamPrint(LOG_SOLVER, 0, "as the output frequency control is used: %d", dasslData->dasslStepsFreq);
infoStreamPrint(LOG_SOLVER, 0, "as the output frequency time step control is used: %f", dasslData->dasslStepsTime);
}
/* if FLAG_DASSL_JACOBIAN is set, choose dassl jacobian calculation method */
if (omc_flag[FLAG_DASSL_JACOBIAN])
{
for(i=1; i< DASSL_JAC_MAX;i++)
{
if(!strcmp((const char*)omc_flagValue[FLAG_DASSL_JACOBIAN], dasslJacobianMethodStr[i])){
dasslData->dasslJacobian = (int)i;
break;
}
}
if(dasslData->dasslJacobian == DASSL_JAC_UNKNOWN)
{
if (ACTIVE_WARNING_STREAM(LOG_SOLVER))
{
warningStreamPrint(LOG_SOLVER, 1, "unrecognized jacobian calculation method %s, current options are:", (const char*)omc_flagValue[FLAG_DASSL_JACOBIAN]);
for(i=1; i < DASSL_JAC_MAX; ++i)
{
warningStreamPrint(LOG_SOLVER, 0, "%-15s [%s]", dasslJacobianMethodStr[i], dasslJacobianMethodDescStr[i]);
}
messageClose(LOG_SOLVER);
}
throwStreamPrint(threadData,"unrecognized jacobian calculation method %s", (const char*)omc_flagValue[FLAG_DASSL_JACOBIAN]);
}
/* default case colored numerical jacobian */
}
else
{
dasslData->dasslJacobian = DASSL_COLOREDNUMJAC;
}
/* selects the calculation method of the jacobian */
if(dasslData->dasslJacobian == DASSL_COLOREDNUMJAC ||
dasslData->dasslJacobian == DASSL_COLOREDSYMJAC ||
dasslData->dasslJacobian == DASSL_NUMJAC ||
dasslData->dasslJacobian == DASSL_SYMJAC)
{
if (data->callback->initialAnalyticJacobianA(data, threadData))
{
infoStreamPrint(LOG_STDOUT, 0, "Jacobian or SparsePattern is not generated or failed to initialize! Switch back to normal.");
dasslData->dasslJacobian = DASSL_INTERNALNUMJAC;
}
else
{
dasslData->info[4] = 1; /* use sub-routine JAC */
}
}
/* set up the appropriate function pointer */
switch (dasslData->dasslJacobian){
case DASSL_COLOREDNUMJAC:
dasslData->jacobianFunction = JacobianOwnNumColored;
break;
case DASSL_COLOREDSYMJAC:
dasslData->jacobianFunction = JacobianSymbolicColored;
break;
case DASSL_SYMJAC:
dasslData->jacobianFunction = JacobianSymbolic;
break;
case DASSL_NUMJAC:
dasslData->jacobianFunction = JacobianOwnNum;
break;
case DASSL_INTERNALNUMJAC:
dasslData->jacobianFunction = dummy_Jacobian;
break;
default:
throwStreamPrint(threadData,"unrecognized jacobian calculation method %s", (const char*)omc_flagValue[FLAG_DASSL_JACOBIAN]);
break;
}
infoStreamPrint(LOG_SOLVER, 0, "jacobian is calculated by %s", dasslJacobianMethodDescStr[dasslData->dasslJacobian]);
/* if FLAG_DASSL_NO_ROOTFINDING is set, choose dassl with out internal root finding */
if(omc_flag[FLAG_DASSL_NO_ROOTFINDING])
{
dasslData->dasslRootFinding = 0;
dasslData->zeroCrossingFunction = dummy_zeroCrossing;
dasslData->ng = 0;
}
else
{
solverInfo->solverRootFinding = 1;
dasslData->dasslRootFinding = 1;
dasslData->zeroCrossingFunction = function_ZeroCrossingsDASSL;
}
infoStreamPrint(LOG_SOLVER, 0, "dassl uses internal root finding method %s", dasslData->dasslRootFinding?"YES":"NO");
/* if FLAG_DASSL_NO_RESTART is set, choose dassl step method */
if (omc_flag[FLAG_DASSL_NO_RESTART])
{
dasslData->dasslAvoidEventRestart = 1; /* TRUE */
}
else
{
dasslData->dasslAvoidEventRestart = 0; /* FALSE */
}
infoStreamPrint(LOG_SOLVER, 0, "dassl performs an restart after an event occurs %s", dasslData->dasslAvoidEventRestart?"NO":"YES");
/* ### end configuration of dassl ### */
messageClose(LOG_SOLVER);
TRACE_POP
return 0;
}
int listLen(LIST *list)
{
assertStreamPrint(NULL, 0 != list, "invalid list-pointer");
return list->length;
}
void *listLastData(LIST *list)
{
assertStreamPrint(NULL, 0 != list, "invalid list-pointer");
assertStreamPrint(NULL, 0 != list->last, "empty list");
return list->last->data;
}
/*! \fn solve linear system with lapack method
*
* \param [in] [data]
* [sysNumber] index of the corresponding linear system
*
* \author wbraun
*/
int solveLapack(DATA *data, int sysNumber)
{
int i, j, iflag = 1;
LINEAR_SYSTEM_DATA* systemData = &(data->simulationInfo.linearSystemData[sysNumber]);
DATA_LAPACK* solverData = (DATA_LAPACK*)systemData->solverData;
int success = 1;
/* We are given the number of the linear system.
* We want to look it up among all equations. */
int eqSystemNumber = systemData->equationIndex;
int indexes[2] = {1,eqSystemNumber};
_omc_scalar residualNorm = 0;
infoStreamPrintWithEquationIndexes(LOG_LS, 0, indexes, "Start solving Linear System %d (size %d) at time %g with Lapack Solver",
eqSystemNumber, (int) systemData->size,
data->localData[0]->timeValue);
/* set data */
_omc_setVectorData(solverData->x, systemData->x);
_omc_setVectorData(solverData->b, systemData->b);
_omc_setMatrixData(solverData->A, systemData->A);
rt_ext_tp_tick(&(solverData->timeClock));
if (0 == systemData->method) {
/* reset matrix A */
memset(systemData->A, 0, (systemData->size)*(systemData->size)*sizeof(double));
/* update matrix A */
systemData->setA(data, systemData);
/* update vector b (rhs) */
systemData->setb(data, systemData);
} else {
/* calculate jacobian -> matrix A*/
if(systemData->jacobianIndex != -1){
getAnalyticalJacobianLapack(data, solverData->A->data, sysNumber);
} else {
assertStreamPrint(data->threadData, 1, "jacobian function pointer is invalid" );
}
/* calculate vector b (rhs) */
_omc_copyVector(solverData->work, solverData->x);
wrapper_fvec_lapack(solverData->work, solverData->b, &iflag, data, sysNumber);
}
infoStreamPrint(LOG_LS, 0, "### %f time to set Matrix A and vector b.", rt_ext_tp_tock(&(solverData->timeClock)));
/* Log A*x=b */
if(ACTIVE_STREAM(LOG_LS_V)){
_omc_printVector(solverData->x, "Vector old x", LOG_LS_V);
_omc_printMatrix(solverData->A, "Matrix A", LOG_LS_V);
_omc_printVector(solverData->b, "Vector b", LOG_LS_V);
}
rt_ext_tp_tick(&(solverData->timeClock));
/* Solve system */
dgesv_((int*) &systemData->size,
(int*) &solverData->nrhs,
solverData->A->data,
(int*) &systemData->size,
solverData->ipiv,
solverData->b->data,
(int*) &systemData->size,
&solverData->info);
infoStreamPrint(LOG_LS, 0, "Solve System: %f", rt_ext_tp_tock(&(solverData->timeClock)));
if(solverData->info < 0)
{
warningStreamPrint(LOG_LS, 0, "Error solving linear system of equations (no. %d) at time %f. Argument %d illegal.", (int)systemData->equationIndex, data->localData[0]->timeValue, (int)solverData->info);
success = 0;
}
else if(solverData->info > 0)
{
warningStreamPrint(LOG_LS, 0,
"Failed to solve linear system of equations (no. %d) at time %f, system is singular for U[%d, %d].",
(int)systemData->equationIndex, data->localData[0]->timeValue, (int)solverData->info+1, (int)solverData->info+1);
success = 0;
/* debug output */
if (ACTIVE_STREAM(LOG_LS)){
_omc_printMatrix(solverData->A, "Matrix U", LOG_LS);
_omc_printVector(solverData->b, "Output vector x", LOG_LS);
}
}
if (1 == success){
if (1 == systemData->method){
/* take the solution */
solverData->x = _omc_addVectorVector(solverData->x, solverData->work, solverData->b);
/* update inner equations */
wrapper_fvec_lapack(solverData->x, solverData->work, &iflag, data, sysNumber);
residualNorm = _omc_euclideanVectorNorm(solverData->work);
} else {
/* take the solution */
_omc_copyVector(solverData->x, solverData->b);
}
if (ACTIVE_STREAM(LOG_LS_V)){
infoStreamPrint(LOG_LS_V, 1, "Residual Norm %f of solution x:", residualNorm);
infoStreamPrint(LOG_LS_V, 0, "System %d numVars %d.", eqSystemNumber, modelInfoGetEquation(&data->modelData.modelDataXml,eqSystemNumber).numVar);
for(i = 0; i < systemData->size; ++i) {
infoStreamPrint(LOG_LS_V, 0, "[%d] %s = %g", i+1, modelInfoGetEquation(&data->modelData.modelDataXml,eqSystemNumber).vars[i], systemData->x[i]);
}
messageClose(LOG_LS_V);
}
}
return success;
}
/*! \fn solve linear system with totalpivot method
*
* \param [in] [data]
* [sysNumber] index of the corresponing non-linear system
*
* \author bbachmann
*/
int solveTotalPivot(DATA *data, threadData_t *threadData, int sysNumber, double* aux_x)
{
void *dataAndThreadData[2] = {data, threadData};
int i, j;
LINEAR_SYSTEM_DATA* systemData = &(data->simulationInfo->linearSystemData[sysNumber]);
DATA_TOTALPIVOT* solverData = (DATA_TOTALPIVOT*) systemData->solverData[1];
int n = systemData->size, status;
double fdeps = 1e-8;
double xTol = 1e-8;
int eqSystemNumber = systemData->equationIndex;
int indexes[2] = {1,eqSystemNumber};
int rank;
/* We are given the number of the linear system.
* We want to look it up among all equations. */
/* int eqSystemNumber = systemData->equationIndex; */
int success = 1;
double tmpJacEvalTime;
infoStreamPrintWithEquationIndexes(LOG_LS, 0, indexes, "Start solving Linear System %d (size %d) at time %g with Total Pivot Solver",
eqSystemNumber, (int) systemData->size,
data->localData[0]->timeValue);
debugVectorDoubleLS(LOG_LS_V,"SCALING",systemData->nominal,n);
debugVectorDoubleLS(LOG_LS_V,"Old VALUES",aux_x,n);
rt_ext_tp_tick(&(solverData->timeClock));
if (0 == systemData->method){
/* reset matrix A */
vecConstLS(n*n, 0.0, systemData->A);
/* update matrix A -> first n columns of matrix Ab*/
systemData->setA(data, threadData, systemData);
vecCopyLS(n*n, systemData->A, solverData->Ab);
/* update vector b (rhs) -> -b is last column of matrix Ab*/
rt_ext_tp_tick(&(solverData->timeClock));
systemData->setb(data, threadData, systemData);
vecScalarMultLS(n, systemData->b, -1.0, solverData->Ab + n*n);
} else {
/* calculate jacobian -> first n columns of matrix Ab*/
if(systemData->jacobianIndex != -1){
getAnalyticalJacobianTotalPivot(data, threadData, solverData->Ab, sysNumber);
} else {
assertStreamPrint(threadData, 1, "jacobian function pointer is invalid" );
}
/* calculate vector b (rhs) -> -b is last column of matrix Ab */
wrapper_fvec_totalpivot(aux_x, solverData->Ab + n*n, dataAndThreadData, sysNumber);
}
tmpJacEvalTime = rt_ext_tp_tock(&(solverData->timeClock));
systemData->jacobianTime += tmpJacEvalTime;
infoStreamPrint(LOG_LS_V, 0, "### %f time to set Matrix A and vector b.", tmpJacEvalTime);
debugMatrixDoubleLS(LOG_LS_V,"LGS: matrix Ab",solverData->Ab, n, n+1);
rt_ext_tp_tick(&(solverData->timeClock));
status = solveSystemWithTotalPivotSearchLS(n, solverData->x, solverData->Ab, solverData->indRow, solverData->indCol, &rank);
infoStreamPrint(LOG_LS_V, 0, "Solve System: %f", rt_ext_tp_tock(&(solverData->timeClock)));
if (status != 0)
{
warningStreamPrint(LOG_STDOUT, 0, "Error solving linear system of equations (no. %d) at time %f.", (int)systemData->equationIndex, data->localData[0]->timeValue);
success = 0;
} else {
debugVectorDoubleLS(LOG_LS_V, "SOLUTION:", solverData->x, n+1);
if (1 == systemData->method){
/* add the solution to old solution vector*/
vecAddLS(n, aux_x, solverData->x, aux_x);
wrapper_fvec_totalpivot(aux_x, solverData->b, dataAndThreadData, sysNumber);
} else {
/* take the solution */
vecCopyLS(n, solverData->x, aux_x);
}
if (ACTIVE_STREAM(LOG_LS_V)){
infoStreamPrint(LOG_LS_V, 1, "Solution x:");
infoStreamPrint(LOG_LS_V, 0, "System %d numVars %d.", eqSystemNumber, modelInfoGetEquation(&data->modelData->modelDataXml,eqSystemNumber).numVar);
for(i=0; i<systemData->size; ++i)
{
infoStreamPrint(LOG_LS_V, 0, "[%d] %s = %g", i+1, modelInfoGetEquation(&data->modelData->modelDataXml,eqSystemNumber).vars[i], aux_x[i]);
}
messageClose(LOG_LS_V);
}
}
return success;
}
LIST_NODE *listFirstNode(LIST *list)
{
assertStreamPrint(NULL, 0 != list, "invalid list-pointer");
assertStreamPrint(NULL, 0 != list->first, "invalid fist list-pointer");
return list->first;
}