From 7ef887367ba49231f6db3d052eb84b587b26ad2a Mon Sep 17 00:00:00 2001 From: Willi Braun Date: Thu, 19 May 2016 19:16:21 +0200 Subject: [PATCH] adjust code generation for daeMode --- Compiler/Template/CodegenC.tpl | 211 +++++++++++++++--- Compiler/Template/SimCodeTV.mo | 8 +- SimulationRuntime/c/openmodelica_func.h | 17 +- SimulationRuntime/c/simulation/solver/dassl.c | 18 +- .../c/simulation/solver/ida_solver.c | 22 +- .../c/simulation/solver/model_help.c | 9 +- SimulationRuntime/c/simulation_data.h | 30 ++- 7 files changed, 245 insertions(+), 70 deletions(-) diff --git a/Compiler/Template/CodegenC.tpl b/Compiler/Template/CodegenC.tpl index 45c74cf8838..a2d1d006bb4 100644 --- a/Compiler/Template/CodegenC.tpl +++ b/Compiler/Template/CodegenC.tpl @@ -161,9 +161,7 @@ end translateModel; extern void <%symbolName(modelNamePrefixStr,"read_input_fmu")%>(MODEL_DATA* modelData, SIMULATION_INFO* simulationData); extern void <%symbolName(modelNamePrefixStr,"function_savePreSynchronous")%>(DATA *data, threadData_t *threadData); extern int <%symbolName(modelNamePrefixStr,"inputNames")%>(DATA* data, char ** names); - extern int <%symbolName(modelNamePrefixStr,"evaluateDAEResiduals")%>(DATA *data, threadData_t *threadData); - extern int <%symbolName(modelNamePrefixStr,"setAlgebraicDAEVars")%>(DATA *data, threadData_t *threadData, double* algebraics); - extern int <%symbolName(modelNamePrefixStr,"getAlgebraicDAEVars")%>(DATA *data, threadData_t *threadData, double* algebraics); + extern int <%symbolName(modelNamePrefixStr,"initializeDAEmodeData")%>(DATA *data, DAEMODE_DATA*); <%\n%> >> end match @@ -804,32 +802,91 @@ template simulationFile_lnz(SimCode simCode) end match end simulationFile_lnz; +template defineSimVarArray(SimVar simVar, String arrayName) + "Generates a define statement for a parameter." +::= + match simVar + case SIMVAR(arrayCref=SOME(c),aliasvar=NOALIAS()) then + << + /* <%crefStrNoUnderscore(c)%> */ + #define <%cref(c)%> data->simulationInfo->daeModeData-><%arrayName%>[<%index%>] + + /* <%crefStrNoUnderscore(name)%> */ + #define <%cref(name)%> data->simulationInfo->daeModeData-><%arrayName%>[<%index%>] + + >> + case SIMVAR(aliasvar=NOALIAS()) then + << + /* <%crefStrNoUnderscore(name)%> */ + #define <%cref(name)%> data->simulationInfo->daeModeData-><%arrayName%>[<%index%>] + + >> + end match +end defineSimVarArray; + +template simulationFile_dae_header(SimCode simCode) +"DAEmode header generation" +::= + match simCode + case simCode as SIMCODE(daeModeData=SOME(DAEMODEDATA(residualVars=residualVars))) then + << + /* residual variable define for daeMode */ + <%residualVars |> var => + defineSimVarArray(var, "residualVars") + ;separator="\n"%> + >> + /* adrpo: leave a newline at the end of file to get rid of the warning */ + end match +end simulationFile_dae_header; + template simulationFile_dae(SimCode simCode) -"Algebraic" +"DAEmode equations generation" ::= match simCode - case SIMCODE(modelInfo=MODELINFO(vars=SIMVARS(__)), daeModeDate=DAEMODEDATA(daeEquations=daeEquations)) then - match modelInfo - case MODELINFO(vars=SIMVARS(__)) then - << - /* DAE residuals */ - <%simulationFileHeader(simCode)%> + case SIMCODE(modelInfo=MODELINFO(vars=SIMVARS(__)), + daeModeData=SOME(DAEMODEDATA(daeEquations=daeEquations, sparsityPattern=sparsityPattern, + algebraicDAEVars=algebraicDAEVars, residualVars=residualVars))) then + let modelNamePrefixStr = modelNamePrefix(simCode) + let initDAEmode = + match sparsityPattern + case SOME((_, _, _, (sparse,_), colorList, maxColor, _)) then + '<%initializeDAEmodeData(listLength(residualVars), listLength(algebraicDAEVars), sparse, colorList, maxColor, modelNamePrefixStr)%>' + case NONE() then + 'int <%symbolName(modelNamePrefixStr,"initializeDAEmodeData")%>(DATA *inData, DAEMODE_DATA* daeModeData){ return -1; }' + end match + << + /* DAE residuals */ + <%simulationFileHeader(simCode)%> + #include "<%fileNamePrefix%>_16dae.h" - #ifdef __cplusplus - extern "C" { - #endif + #ifdef __cplusplus + extern "C" { + #endif + <%evaluateDAEResiduals(daeEquations, modelNamePrefixStr)%> - <%evaluateDAEResiduals(daeEquations, modelNamePrefix(simCode))%> + <%algebraicDAEVar(algebraicDAEVars, modelNamePrefixStr)%> - <%algebraicDAEVar(vars.algebraicDAEVars, modelNamePrefix(simCode))%> + <%initDAEmode%> - #ifdef __cplusplus - } - #endif<%\n%> - >> - /* adrpo: leave a newline at the end of file to get rid of the warning */ - end match + #ifdef __cplusplus + } + #endif<%\n%> + >> + /* adrpo: leave a newline at the end of file to get rid of the warning */ + else + let modelNamePrefixStr = modelNamePrefix(simCode) + << + /* DAE residuals is empty */ + <%simulationFileHeader(simCode)%> + #ifdef __cplusplus + extern "C" { + #endif + int <%symbolName(modelNamePrefixStr,"initializeDAEmodeData")%>(DATA *inData, DAEMODE_DATA* daeModeData){ return -1; } + #ifdef __cplusplus + } + #endif<%\n%> + >> end match end simulationFile_dae; @@ -940,12 +997,10 @@ template simulationFile(SimCode simCode, String guid, Boolean isModelExchangeFMU <%symbolName(modelNamePrefixStr,"initialLinearSystem")%>, <%symbolName(modelNamePrefixStr,"initialMixedSystem")%>, <%symbolName(modelNamePrefixStr,"initializeStateSets")%>, + <%symbolName(modelNamePrefixStr,"initializeDAEmodeData")%>, <%symbolName(modelNamePrefixStr,"functionODE")%>, <%symbolName(modelNamePrefixStr,"functionAlgebraics")%>, <%symbolName(modelNamePrefixStr,"functionDAE")%>, - <%symbolName(modelNamePrefixStr,"evaluateDAEResiduals")%>, - <%symbolName(modelNamePrefixStr,"setAlgebraicDAEVars")%>, - <%symbolName(modelNamePrefixStr,"getAlgebraicDAEVars")%>, <%symbolName(modelNamePrefixStr,"input_function")%>, <%symbolName(modelNamePrefixStr,"input_function_init")%>, <%symbolName(modelNamePrefixStr,"input_function_updateStartValues")%>, @@ -1181,9 +1236,6 @@ template populateModelInfo(ModelInfo modelInfo, String fileNamePrefix, String gu data->modelData->nClocks = <%nClocks%>; data->modelData->nSubClocks = <%nSubClocks%>; - data->modelData->nResidualVars = <%listLength(vars.residualVars)%>; - data->modelData->nAlgebraicDAEVars = <%listLength(vars.algebraicDAEVars)%>; - data->modelData->nSensitivityVars = <%listLength(vars.sensitivityVars)%>; data->modelData->nSensitivityParamVars = <%varInfo.numSensitivityParameters%>; >> @@ -1278,11 +1330,6 @@ template variableDefinitions(ModelInfo modelInfo, list tim globalDataVarDefine(var, "realVars") ;separator="\n"%> - /* residual variables of DAE solution method */ - <%vars.residualVars |> var => - globalDataParDefine(var, "residualVars") - ;separator="\n"%> - /* Algebraic Parameter */ <%vars.paramVars |> var => globalDataParDefine(var, "realParameter") @@ -3760,7 +3807,7 @@ template evaluateDAEResiduals(list> resEquations, String model <%systems%> /* for residuals DAE variables */ - int <%symbolName(modelNamePrefix,"evaluateDAEResiduals")%>(DATA *data, threadData_t *threadData) + int <%symbolName(modelNamePrefix,"evaluateDAEResiduals")%>(DATA *data, threadData_t *threadData, double* residualVars) { TRACE_PUSH data->simulationInfo->callStatistics.functionEvalDAE++; @@ -3811,6 +3858,61 @@ template algebraicDAEVar(list algVars, String modelNamePrefix) >> end algebraicDAEVar; +template initializeDAEmodeData(Integer nResVars, Integer nAlgVars, list>> sparsepattern, list> colorList, Integer maxColor, String modelNamePrefix) + "Generates initialization function for daeMode." +::= + let sizeCols = listLength(sparsepattern) + let sizeNNZ = lengthListElements(unzipSecond(sparsepattern)) + let colPtr = genSPCRSPtr(listLength(sparsepattern), sparsepattern, "colPtrIndex") + let rowIndex = genSPCRSRows(lengthListElements(unzipSecond(sparsepattern)), sparsepattern, "rowIndex") + let colorString = genSPColors(colorList, "daeModeData->sparsePattern->colorCols") + let maxColorStr = '<%maxColor%>' + << + /* initialize the daeMode variables */ + int <%symbolName(modelNamePrefix,"initializeDAEmodeData")%>(DATA *inData, DAEMODE_DATA* daeModeData) + { + TRACE_PUSH + DATA* data = ((DATA*)inData); + /* sparse patterns */ + <%colPtr%> + <%rowIndex%> + int i = 0; + + daeModeData->nResidualVars = <%nResVars%>; + daeModeData->nAlgebraicDAEVars = <%nAlgVars%>; + + daeModeData->residualVars = (double*) malloc(sizeof(double)*<%nResVars%>); + + /* set the function pointer */ + daeModeData->evaluateDAEResiduals = <%symbolName(modelNamePrefix,"evaluateDAEResiduals")%>; + daeModeData->setAlgebraicDAEVars = <%symbolName(modelNamePrefix,"setAlgebraicDAEVars")%>; + daeModeData->getAlgebraicDAEVars = <%symbolName(modelNamePrefix,"getAlgebraicDAEVars")%>; + + /* intialize sparse pattern */ + daeModeData->sparsePattern = (SPARSE_PATTERN*) malloc(sizeof(SPARSE_PATTERN)); + + daeModeData->sparsePattern->leadindex = (unsigned int*) malloc((<%sizeCols%>+1)*sizeof(int)); + daeModeData->sparsePattern->index = (unsigned int*) malloc(<%sizeNNZ%>*sizeof(int)); + daeModeData->sparsePattern->numberOfNoneZeros = <%sizeNNZ%>; + daeModeData->sparsePattern->colorCols = (unsigned int*) malloc(<%sizeCols%>*sizeof(int)); + daeModeData->sparsePattern->maxColors = <%maxColorStr%>; + + /* write lead index of compressed sparse column */ + memcpy(daeModeData->sparsePattern->leadindex, colPtrIndex, (1+<%sizeCols%>)*sizeof(int)); + /* makek CRS compatible */ + for(i=2;i<=<%sizeCols%>;++i) + daeModeData->sparsePattern->leadindex[i] += daeModeData->sparsePattern->leadindex[i-1]; + /* call sparse index */ + memcpy(daeModeData->sparsePattern->index, rowIndex, <%sizeNNZ%>*sizeof(int)); + + /* write color array */ + <%colorString%> + TRACE_POP + return 0; + } + >> +end initializeDAEmodeData; + template functionDAE(list allEquationsPlusWhen, String modelNamePrefix) "Generates function in simulation file. This is a helper of template simulationFile." @@ -4459,6 +4561,49 @@ template functionJac(list jacEquations, list tmpVars, Strin >> end functionJac; +// function for sparsity pattern generation +template genSPCRSPtr(Integer sizeColPtr, list>> sparsepattern, String constArrayName) +"This template generates colPtr of the CRS format" +::= + let colPtrindex = (sparsepattern |> (i, indexes) => + << + <%listLength(indexes)%> + >> + ;separator=",") + << + const int <%constArrayName%>[1+<%sizeColPtr%>] = {0,<%colPtrindex%>}; + >> +end genSPCRSPtr; + +template genSPCRSRows(Integer nonZeroElems, list>> sparsepattern, String constArrayName) +"This template generates row of the CRS format" +::= + let rowsIndex = ( sparsepattern |> (i, indexes) hasindex index0 => + ( indexes |> indexrow => + << + <%indexrow%> + >> + ;separator=",") + ;separator=",") + << + const int <%constArrayName%>[<%nonZeroElems%>] = {<%rowsIndex%>}; + >> +end genSPCRSRows; + +template genSPColors(list> colorList, String arrayName) +"This template generates row of the CRS format" +::= + let colorArray = (colorList |> (indexes) hasindex index0 => + let colorCol = ( indexes |> i_index => + <<<%arrayName%>[<%i_index%>] = <%intAdd(index0,1)%>;>> + ;separator="\n") + '<%colorCol%>' + ;separator="\n") + << + <%colorArray%> + >> +end genSPColors; + template equation_arrayFormat(SimEqSystem eq, String name, Context context, Integer arrayIndex, Text &eqArray, Text &eqfuncs, String modelNamePrefix) "Generates an equation. This template should not be used for a SES_RESIDUAL. diff --git a/Compiler/Template/SimCodeTV.mo b/Compiler/Template/SimCodeTV.mo index ba6b291cc30..38cc39476d0 100644 --- a/Compiler/Template/SimCodeTV.mo +++ b/Compiler/Template/SimCodeTV.mo @@ -314,7 +314,7 @@ package SimCode HashTableCrIListArray.HashTable varToArrayIndexMapping; Option modelStructure; PartitionData partitionData; - DaeModeDate daeModeDate; + Option daeModeData; end SIMCODE; end SimCode; @@ -613,13 +613,15 @@ package SimCode end VARINFO; end VarInfo; - uniontype DaeModeDate + uniontype DaeModeData "contains data that belongs to the dae mode" record DAEMODEDATA list> daeEquations "daeModel residuals equations"; Option sparsityPattern "contains the sparsity pattern for the daeMode"; + list residualVars; // variable used to calculate residuals of a DAE form, they are real + list algebraicDAEVars; // variable used to calculate residuals of a DAE form, they are real end DAEMODEDATA; - end DaeModeDate; + end DaeModeData; uniontype Function record FUNCTION diff --git a/SimulationRuntime/c/openmodelica_func.h b/SimulationRuntime/c/openmodelica_func.h index ba23357f0a2..47195eb37c7 100644 --- a/SimulationRuntime/c/openmodelica_func.h +++ b/SimulationRuntime/c/openmodelica_func.h @@ -95,6 +95,14 @@ void (*initialMixedSystem)(int nMixedSystems, MIXED_SYSTEM_DATA *data); */ void (*initializeStateSets)(int nStateSets, STATE_SET_DATA* statesetData, DATA *data); +/*! \fn initializeDAEmodeData + * + * This function to initialize the daeMode data structure in Data + * + * \param [ref] [data] + */ +int (*initializeDAEmodeData)(DATA *data, DAEMODE_DATA* daeModeData); + /* functionODE contains those equations that are needed * to calculate the dynamic part of the system */ int (*functionODE)(DATA *data, threadData_t*); @@ -107,15 +115,6 @@ int (*functionAlgebraics)(DATA *data, threadData_t*); uses in EventHandle */ int (*functionDAE)(DATA *data, threadData_t*); -/* function to evaluate dynamic equations for DAE solver*/ -int (*evaluateDAEResiduals)(DATA *data, threadData_t*); - -/* function to set algebraic DAE Variable form solver*/ -int (*setAlgebraicDAEVars)(DATA *data, threadData_t*, double *algebraics); - -/* function to get algebraic DAE Variable form solver*/ -int (*getAlgebraicDAEVars)(DATA *data, threadData_t*, double *algebraics); - /* functions for input and output */ int (*input_function)(DATA*, threadData_t*); int (*input_function_init)(DATA*, threadData_t*); diff --git a/SimulationRuntime/c/simulation/solver/dassl.c b/SimulationRuntime/c/simulation/solver/dassl.c index aaa22ccec40..a7509a70200 100644 --- a/SimulationRuntime/c/simulation/solver/dassl.c +++ b/SimulationRuntime/c/simulation/solver/dassl.c @@ -141,7 +141,7 @@ int dassl_initial(DATA* data, threadData_t *threadData, SOLVER_INFO* solverInfo, { dasslData->daeMode = 1; dasslData->residualFunction = functionDAE_residual; - N = data->modelData->nStates + data->modelData->nAlgebraicDAEVars; + N = data->modelData->nStates + data->simulationInfo->daeModeData->nAlgebraicDAEVars; NDAE = N; } else @@ -546,7 +546,7 @@ int dassl_step(DATA* data, threadData_t *threadData, SOLVER_INFO* solverInfo) if (dasslData->daeMode) { memcpy(states, data->localData[0]->realVars, sizeof(double)*data->modelData->nStates); - data->callback->getAlgebraicDAEVars(data, threadData, states + data->modelData->nStates); + data->simulationInfo->daeModeData->getAlgebraicDAEVars(data, threadData, states + data->modelData->nStates); memcpy(stateDer, data->localData[1]->realVars + data->modelData->nStates, sizeof(double)*data->modelData->nStates); } } @@ -666,7 +666,7 @@ int dassl_step(DATA* data, threadData_t *threadData, SOLVER_INFO* solverInfo) if (dasslData->daeMode) { memcpy(data->localData[0]->realVars, states, sizeof(double)*data->modelData->nStates); - data->callback->setAlgebraicDAEVars(data, threadData, states + data->modelData->nStates); + data->simulationInfo->daeModeData->setAlgebraicDAEVars(data, threadData, states + data->modelData->nStates); memcpy(data->localData[0]->realVars + data->modelData->nStates, stateDer, sizeof(double)*data->modelData->nStates); } else @@ -878,7 +878,7 @@ int functionDAE_residual(double *t, double *y, double *yd, double* cj, double *d memcpy(data->localData[0]->realVars, y, sizeof(double)*data->modelData->nStates); memcpy(data->localData[0]->realVars + data->modelData->nStates, yd, sizeof(double)*data->modelData->nStates); - data->callback->setAlgebraicDAEVars(data, threadData, y + data->modelData->nStates); + data->simulationInfo->daeModeData->setAlgebraicDAEVars(data, threadData, y + data->modelData->nStates); saveJumpState = threadData->currentErrorStage; threadData->currentErrorStage = ERROR_INTEGRATOR; @@ -893,14 +893,14 @@ int functionDAE_residual(double *t, double *y, double *yd, double* cj, double *d data->callback->input_function(data, threadData); /* eval residual vars */ - data->callback->evaluateDAEResiduals(data, threadData); + data->simulationInfo->daeModeData->evaluateDAEResiduals(data, threadData); /* get data->simulationInfo->residualVars */ - for(i=0; i < data->modelData->nResidualVars; i++) + for(i=0; i < data->simulationInfo->daeModeData->nResidualVars; i++) { - delta[i] = data->simulationInfo->residualVars[i]; + delta[i] = data->simulationInfo->daeModeData->residualVars[i]; } - printVector(LOG_DASSL_STATES, "residual", delta, data->modelData->nResidualVars, *t); + printVector(LOG_DASSL_STATES, "residual", delta, data->simulationInfo->daeModeData->nResidualVars, *t); success = 1; #if !defined(OMC_EMCC) MMC_CATCH_INTERNAL(simulationJumpBuffer) @@ -948,7 +948,7 @@ int function_ZeroCrossingsDASSL(int *neqm, double *t, double *y, double *yp, { memcpy(data->localData[0]->realVars, y, sizeof(double)*data->modelData->nStates); memcpy(data->localData[0]->realVars + data->modelData->nStates, yp, sizeof(double)*data->modelData->nStates); - data->callback->setAlgebraicDAEVars(data, threadData, y + data->modelData->nStates); + data->simulationInfo->daeModeData->setAlgebraicDAEVars(data, threadData, y + data->modelData->nStates); } /* read input vars */ diff --git a/SimulationRuntime/c/simulation/solver/ida_solver.c b/SimulationRuntime/c/simulation/solver/ida_solver.c index b20b44fcf93..0ec81e4757d 100644 --- a/SimulationRuntime/c/simulation/solver/ida_solver.c +++ b/SimulationRuntime/c/simulation/solver/ida_solver.c @@ -150,7 +150,7 @@ ida_solver_initial(DATA* data, threadData_t *threadData, SOLVER_INFO* solverInfo { idaData->daeMode = 1; idaData->residualFunction = residualFunctionIDADAEmode; - idaData->N = data->modelData->nStates + data->modelData->nAlgebraicDAEVars; + idaData->N = data->modelData->nStates + data->simulationInfo->daeModeData->nAlgebraicDAEVars; } else { @@ -166,7 +166,7 @@ ida_solver_initial(DATA* data, threadData_t *threadData, SOLVER_INFO* solverInfo memcpy(idaData->states, data->localData[0]->realVars, sizeof(double)*data->modelData->nStates); // and also algebraic vars - data->callback->getAlgebraicDAEVars(data, threadData, idaData->states + data->modelData->nStates); + data->simulationInfo->daeModeData->getAlgebraicDAEVars(data, threadData, idaData->states + data->modelData->nStates); memcpy(idaData->statesDer, data->localData[1]->realVars + data->modelData->nStates, sizeof(double)*data->modelData->nStates); idaData->y = N_VMake_Serial(idaData->N, idaData->states); @@ -550,7 +550,7 @@ ida_solver_step(DATA* data, threadData_t *threadData, SOLVER_INFO* solverInfo) { memcpy(idaData->states, data->localData[0]->realVars, sizeof(double)*data->modelData->nStates); /* and also algebraic vars */ - data->callback->getAlgebraicDAEVars(data, threadData, idaData->states + data->modelData->nStates); + data->simulationInfo->daeModeData->getAlgebraicDAEVars(data, threadData, idaData->states + data->modelData->nStates); memcpy(idaData->statesDer, data->localData[1]->realVars + data->modelData->nStates, sizeof(double)*data->modelData->nStates); } flag = IDAReInit(idaData->ida_mem, @@ -682,7 +682,7 @@ ida_solver_step(DATA* data, threadData_t *threadData, SOLVER_INFO* solverInfo) { memcpy(data->localData[0]->realVars, idaData->states, sizeof(double)*data->modelData->nStates); // and also algebraic vars - data->callback->setAlgebraicDAEVars(data, threadData, idaData->states + data->modelData->nStates); + data->simulationInfo->daeModeData->setAlgebraicDAEVars(data, threadData, idaData->states + data->modelData->nStates); memcpy(data->localData[0]->realVars + data->modelData->nStates, idaData->statesDer, sizeof(double)*data->modelData->nStates); } @@ -783,7 +783,7 @@ int residualFunctionIDA(double time, N_Vector yy, N_Vector yp, N_Vector res, voi #if !defined(OMC_EMCC) MMC_TRY_INTERNAL(simulationJumpBuffer) #endif - + data->simulationInfo->daeModeData->setAlgebraicDAEVars(data, threadData, idaData->states + data->modelData->nStates); /* if sensitivity mode update also bound parameters*/ if (idaData->idaSmode) { @@ -862,7 +862,7 @@ int residualFunctionIDADAEmode(double time, N_Vector yy, N_Vector yp, N_Vector r */ memcpy(data->localData[0]->realVars, idaData->states, sizeof(double)*data->modelData->nStates); memcpy(data->localData[0]->realVars + data->modelData->nStates, idaData->statesDer, sizeof(double)*data->modelData->nStates); - data->callback->setAlgebraicDAEVars(data, threadData, idaData->states + data->modelData->nStates); + data->simulationInfo->daeModeData->setAlgebraicDAEVars(data, threadData, idaData->states + data->modelData->nStates); saveJumpState = threadData->currentErrorStage; threadData->currentErrorStage = ERROR_INTEGRATOR; @@ -877,14 +877,14 @@ int residualFunctionIDADAEmode(double time, N_Vector yy, N_Vector yp, N_Vector r data->callback->input_function(data, threadData); /* eval residual vars */ - data->callback->evaluateDAEResiduals(data, threadData); + data->simulationInfo->daeModeData->evaluateDAEResiduals(data, threadData); /* get data->simulationInfo->residualVars */ - for(i=0; i < data->modelData->nResidualVars; i++) + for(i=0; i < idaData->N; i++) { - NV_Ith_S(res, i) = data->simulationInfo->residualVars[i]; + NV_Ith_S(res, i) = data->simulationInfo->daeModeData->residualVars[i]; } - printVector(LOG_DASSL_STATES, "residual", delta, data->modelData->nResidualVars, time); + printVector(LOG_DASSL_STATES, "residual", delta, idaData->N, time); success = 1; #if !defined(OMC_EMCC) MMC_CATCH_INTERNAL(simulationJumpBuffer) @@ -930,7 +930,7 @@ int rootsFunctionIDA(double time, N_Vector yy, N_Vector yp, double *gout, void* if (idaData->daeMode) { memcpy(data->localData[0]->realVars, idaData->states, sizeof(double)*data->modelData->nStates); - data->callback->setAlgebraicDAEVars(data, threadData, idaData->states + data->modelData->nStates); + data->simulationInfo->daeModeData->setAlgebraicDAEVars(data, threadData, idaData->states + data->modelData->nStates); memcpy(data->localData[0]->realVars + data->modelData->nStates, idaData->statesDer, sizeof(double)*data->modelData->nStates); } diff --git a/SimulationRuntime/c/simulation/solver/model_help.c b/SimulationRuntime/c/simulation/solver/model_help.c index 266877236df..b1b1759c98e 100644 --- a/SimulationRuntime/c/simulation/solver/model_help.c +++ b/SimulationRuntime/c/simulation/solver/model_help.c @@ -955,8 +955,6 @@ void initializeDataStruc(DATA *data, threadData_t *threadData) /* buffer for inputs and outputs values */ data->simulationInfo->inputVars = (modelica_real*) calloc(data->modelData->nInputVars, sizeof(modelica_real)); data->simulationInfo->outputVars = (modelica_real*) calloc(data->modelData->nOutputVars, sizeof(modelica_real)); - /* buffer for residual values of DAE solver*/ - data->simulationInfo->residualVars = (modelica_real*) calloc(data->modelData->nResidualVars, sizeof(modelica_real)); /* buffer for mixed systems */ data->simulationInfo->mixedSystemData = (MIXED_SYSTEM_DATA*) omc_alloc_interface.malloc_uncollectable(data->modelData->nMixedSystems*sizeof(MIXED_SYSTEM_DATA)); @@ -974,6 +972,10 @@ void initializeDataStruc(DATA *data, threadData_t *threadData) data->simulationInfo->stateSetData = (STATE_SET_DATA*) omc_alloc_interface.malloc_uncollectable(data->modelData->nStateSets*sizeof(STATE_SET_DATA)); data->callback->initializeStateSets(data->modelData->nStateSets, data->simulationInfo->stateSetData, data); + /* buffer for daeMode */ + data->simulationInfo->daeModeData = (DAEMODE_DATA*) omc_alloc_interface.malloc_uncollectable(sizeof(DAEMODE_DATA)); + data->callback->initializeDAEmodeData(data, data->simulationInfo->daeModeData); + /* buffer for analytical jacobians */ data->simulationInfo->analyticJacobians = (ANALYTIC_JACOBIAN*) omc_alloc_interface.malloc_uncollectable(data->modelData->nJacobians*sizeof(ANALYTIC_JACOBIAN)); @@ -1134,6 +1136,9 @@ void deInitializeDataStruc(DATA *data) /* free buffer jacobians */ omc_alloc_interface.free_uncollectable(data->simulationInfo->analyticJacobians); + /* free buffer for state sets */ + omc_alloc_interface.free_uncollectable(data->simulationInfo->daeModeData); + /* free inputs and output */ free(data->simulationInfo->inputVars); free(data->simulationInfo->outputVars); diff --git a/SimulationRuntime/c/simulation_data.h b/SimulationRuntime/c/simulation_data.h index 7e6c028b640..674e4f19c26 100644 --- a/SimulationRuntime/c/simulation_data.h +++ b/SimulationRuntime/c/simulation_data.h @@ -384,6 +384,31 @@ typedef struct STATE_SET_DATA modelica_integer jacobianIndex; }STATE_SET_DATA; +typedef struct DAEMODE_DATA +{ + /* number of dae residual variables */ + long nResidualVars; + + /* number of algebraic variables */ + long nAlgebraicDAEVars; + + /* workspace for the residual variables */ + modelica_real* residualVars; + + /* daeMode sparse pattern */ + SPARSE_PATTERN* sparsePattern; + + /* function to evaluate dynamic equations for DAE solver*/ + int (*evaluateDAEResiduals)(struct DATA*, threadData_t*); + + /* function to set algebraic DAE Variable form solver*/ + int (*setAlgebraicDAEVars)(struct DATA*, threadData_t*, double*); + + /* function to get algebraic DAE Variable form solver*/ + int (*getAlgebraicDAEVars)(struct DATA*, threadData_t*, double*); +} DAEMODE_DATA; + + typedef struct MODEL_DATA_XML { const char *fileName; @@ -477,8 +502,6 @@ typedef struct MODEL_DATA long nAliasString; long nJacobians; - long nResidualVars; - long nAlgebraicDAEVars; long nSensitivityVars; long nSensitivityParamVars; @@ -577,7 +600,6 @@ typedef struct SIMULATION_INFO modelica_real* inputVars; modelica_real* outputVars; EXTERNAL_INPUT external_input; - modelica_real* residualVars; /* used by integrators in dae solver mode */ modelica_real* sensitivityMatrix; /* used by integrator for sensitivity mode */ int* sensitivityParList; /* used by integrator for sensitivity mode */ @@ -594,6 +616,8 @@ typedef struct SIMULATION_INFO STATE_SET_DATA* stateSetData; + DAEMODE_DATA* daeModeData; + /* delay vars */ double tStart; RINGBUFFER **delayStructure;