diff --git a/src/mmoc/tests/system/gt_data/allow_discrete_integer/allow_discrete_integer.c b/src/mmoc/tests/system/gt_data/allow_discrete_integer/allow_discrete_integer.c new file mode 100644 index 00000000..9bd85a4e --- /dev/null +++ b/src/mmoc/tests/system/gt_data/allow_discrete_integer/allow_discrete_integer.c @@ -0,0 +1,162 @@ +#include +#include +#include +#include + +#include "allow_discrete_integer.h" +#include +#include +#include +#include +#include + +void MOD_settings(SD_simulationSettings settings) +{ + settings->debug = 0; + settings->parallel = FALSE; + settings->hybrid = TRUE; + settings->method = 0; +} + +void MOD_definition(int idx, double *x, double *d, double *a, double t, double *dx) +{ + int _d1; + int i; + if (_is_var_u(idx)) { + _get_u_idxs(idx); + _apply_usage_eq_1(_d1); + if ((i >= 1 && i <= 1000)) { + _der_u(i,0) = _time; + + + } + return; + } +} + +void MOD_zeroCrossing(int idx, double *x, double *d, double *a, double t, double *zc) +{ + switch(idx) { + case _eval_event_1: { + _zc(0) = _time-(0); + + + return; + } + } +} + +void MOD_handlerPos(int idx, double *x, double* q, double *d, double *a, double t) +{ + switch(idx) { + case _eval_event_1: { + _init_u((int)_d,0) = 0; + return; + } + } +} + +void MOD_handlerNeg(int idx, double *x, double* q, double *d, double *a, double t) +{ +} + +void MOD_output(int idx, double *x, double *d, double *a, double t, double *out) +{ +} + +void MOD_jacobian(double *x, double *d, double *a, double t, SD_jacMatrices dvdx, double *jac) +{ + int row, row_t, eq_var, c_row, c_row_g; + int col, col_g, col_t; + int x_ind; + double aux; + int _d1; + int _rg_d1; + int i; + SD_cleanJacMatrices(dvdx); + for(row = 1; row <= 1000; row++) { + c_row = _c_index(row); + _get_eq_1_var_idxs(row, eq_var); + _get_u_idxs(eq_var); + } + // Assign Jacobian Matrix values for equation: 0 + for (row = 0; row < 1000; row++) { + for (col = 0; col < dvdx->df_dx[0]->size[row]; col++) { + row_t = dvdx->df_dx[0]->index[row][col]; + _assign_jac(row_t, dvdx->df_dx[0]->value[row][col]); + } + } +} + +void MOD_dependencies(int idx, double *x, double *d, double *a, double t, double *dx, int *map) +{ +} + +void MOD_BDF_definition(double *x, double *d, double *a, double t, double *dx, int *BDFMap, int nBDF) +{ + int idx; + int __bdf_it; + for(__bdf_it = 0; __bdf_it < nBDF; __bdf_it++) { + idx = BDFMap[__bdf_it]; + int _d1; + int i; + if (_is_var_u(idx)) { + _get_u_idxs(idx); + _apply_usage_eq_1(_d1); + if ((i >= 1 && i <= 1000)) { + _eval_dep_u(i,1) = _time; + + + } + continue; + } + } +} + +void QSS_initializeDataStructs(QSS_simulator simulator) +{ + simulator->data = QSS_Data(1000,1,1,1000,0,1,0,"allow_discrete_integer"); + QSS_data modelData = simulator->data; + MODEL_DATA_ACCESS(modelData) + int* states = (int*) malloc(1000*sizeof(int)); + int* discretes = (int*) malloc(1*sizeof(int)); + int* events = (int*) malloc(1*sizeof(int)); + int row, eq_var, c_row; + int x_ind; + int _d1; + int _rg_d1; + int i; + for(row = 1; row <= 1000; row++) { + c_row = _c_index(row); + _get_eq_1_var_idxs(row, eq_var); + _get_u_idxs(eq_var); + } + modelData->event[_idx_event_1].nLHSSt++; + QSS_allocDataMatrix(modelData); + cleanVector(states, 0, 1000); + for(row = 1; row <= 1000; row++) { + c_row = _c_index(row); + _get_eq_1_var_idxs(row, eq_var); + _get_u_idxs(eq_var); + } + cleanVector(events, 0, 1); + modelData->event[_idx_event_1].LHSSt[events[_idx_event_1]++] = _idx_u(0,0); + modelData->event[_idx_event_1].direction = 1; + modelData->event[_idx_event_1].relation = 2; + SD_setupJacMatrices(modelData->jac_matrices); + simulator->time = QSS_Time(1000,1,1000,0,ST_Binary, NULL); + for(i = 1; i<=1000; i+=1) { + modelData->IT[_input_1(i)] = _idx_u(i,0); + } + simulator->output = SD_Output("allow_discrete_integer",0,1,1000,NULL,0,0,CI_Step,SD_Memory,NULL); + SD_output modelOutput = simulator->output; + simulator->model = QSS_Model(MOD_definition, MOD_dependencies, MOD_zeroCrossing, MOD_handlerPos, MOD_handlerNeg, MOD_jacobian, MOD_BDF_definition); + free(states); + free(discretes); + free(events); +} + +void CLC_initializeDataStructs(CLC_simulator simulator) +{ +} + diff --git a/src/mmoc/tests/system/gt_data/allow_discrete_integer/allow_discrete_integer.h b/src/mmoc/tests/system/gt_data/allow_discrete_integer/allow_discrete_integer.h new file mode 100644 index 00000000..7dbedb9b --- /dev/null +++ b/src/mmoc/tests/system/gt_data/allow_discrete_integer/allow_discrete_integer.h @@ -0,0 +1,66 @@ +// Model data access macro. + +#define MODEL_DATA_ACCESS(m) \ + double* x = m->x; \ + double* d = m->d; + +// Coeff multipliers definition. + +#define COEFF_MULTIPLIER(c) COEFF_MULTIPLIER_##c +#define COEFF_MULTIPLIER_0 1 +#define COEFF_MULTIPLIER_1 1 + +// Model Variables Macros + +// Macros definition for variable: _event_1 +#define _idx_event_1 0 +#define _eval_event_1 0 + +// Macros definition for variable: d +#define _idx_d 0 +#define _d d[_idx_d] + +// Macros definition for variable: u +#define _idx_u(d1,coeff) ((d1-1)) +#define _state_idx_u(d1,coeff) ((d1-1))*2 + coeff +#define _u(d1,coeff) x[_state_idx_u(d1,coeff)] * COEFF_MULTIPLIER(coeff) +#define _init_u(d1,coeff) x[_state_idx_u(d1,coeff)] +#define _q_u(d1,coeff) q[_state_idx_u(d1,coeff)] * COEFF_MULTIPLIER(coeff) +#define _eval_u(d1,coeff) ((d1-1)) +#define _is_var_u(idx) idx >= 0 && idx < 1000 +#define _get_u_idxs(idx)\ + _d1 = (idx)+ 1; +#define _eval_dep_u(d1,coeff) dx[_state_idx_u(d1,coeff)] + + +// Derivative Equations Macros + +// Macros for equation: 1 +#define _apply_usage_eq_1(_d1) \ + i = _d1; +#define _get_eq_1_var_idxs(row, var)\ + _rg_d1 = 0 + (row-1)+ 1;\ + var = _idx_u(_rg_d1,0); + +// Event Macros + +// Macros for event: 1 + +#define _zc(coeff) zc[coeff] + +// Input Matrix Macros + +#define _input_1(i) ((i-1)) + +// Jacobian Macros definition. +#define _assign_jac(r, val) \ + col_t = dvdx->df_dx_t->size[r] + dvdx->df_dx_t->index[r][0]; \ + dvdx->df_dx_t->index[r][0]++; \ + jac[col_t] = val; +#define _c_index(i) (i-1) + +#define _time t + +// Derivative Macros definition. +// Derivative definition for variable: u +#define _der_u(d1,coeff) dx[coeff+1] diff --git a/src/mmoc/tests/system/gt_data/allow_discrete_integer/allow_discrete_integer.ini b/src/mmoc/tests/system/gt_data/allow_discrete_integer/allow_discrete_integer.ini new file mode 100644 index 00000000..191278e7 --- /dev/null +++ b/src/mmoc/tests/system/gt_data/allow_discrete_integer/allow_discrete_integer.ini @@ -0,0 +1,15 @@ +minstep=1.00000e-14; +zchyst=1.00000e-12; +derdelta=1.00000e-08; +symdiff=1; +lps=0; +nodesize=10000; +jacobian=1; +it=0.00000e+00; +ft=1.00000e+01; +sol="QSS"; +dqmin=(1.00000e-03); +dqrel=(1.00000e-03); +bdf=0; +BDFPartitionDepth=1; +BDFMaxStep=0.00000e+00; diff --git a/src/mmoc/tests/system/gt_data/allow_discrete_integer/allow_discrete_integer.mo b/src/mmoc/tests/system/gt_data/allow_discrete_integer/allow_discrete_integer.mo new file mode 100644 index 00000000..62609124 --- /dev/null +++ b/src/mmoc/tests/system/gt_data/allow_discrete_integer/allow_discrete_integer.mo @@ -0,0 +1,30 @@ +model allow_discrete_integer + constant Integer N=1000; + Real u[N]; + discrete Integer d; + +equation + for i in 1:N loop + der(u[i])=time; + end for; + +algorithm + when time > 0 then + reinit(u[d],0); + end when; + annotation( + experiment( + MMO_Description="Use time variable in initialization code.", + + MMO_Solver=QSS, + MMO_PartitionMethod=Metis, + Jacobian=Dense, + MMO_BDF_PDepth=1, + MMO_BDF_Max_Step=0, + MMO_RandomSeed=0, + StartTime=0, + StopTime=10, + Tolerance={1e-3}, + AbsTolerance={1e-3} + )); +end allow_discrete_integer; diff --git a/src/mmoc/tests/system/models_test.cpp b/src/mmoc/tests/system/models_test.cpp index 0952e689..304471b8 100644 --- a/src/mmoc/tests/system/models_test.cpp +++ b/src/mmoc/tests/system/models_test.cpp @@ -65,6 +65,7 @@ const char* models[] = {"adr", "advectionFlux", "airconds", "aircont", + "allow_discrete_integer", "bball_downstairs", "boost", "BouncingBall",