From f981c15863952eae625b58276fe11ff2bff9a9d5 Mon Sep 17 00:00:00 2001 From: "joaquin.f.fernandez" Date: Tue, 27 Aug 2024 14:53:20 -0300 Subject: [PATCH] Added mmoc system test. --- .../virus_replication/virus_replication.c | 429 ++++++++++++++++++ .../virus_replication/virus_replication.h | 162 +++++++ .../virus_replication/virus_replication.ini | 15 + .../virus_replication/virus_replication.mo | 65 +++ src/mmoc/tests/system/models_test.cpp | 45 +- 5 files changed, 678 insertions(+), 38 deletions(-) create mode 100644 src/mmoc/tests/system/gt_data/virus_replication/virus_replication.c create mode 100644 src/mmoc/tests/system/gt_data/virus_replication/virus_replication.h create mode 100644 src/mmoc/tests/system/gt_data/virus_replication/virus_replication.ini create mode 100644 src/mmoc/tests/system/gt_data/virus_replication/virus_replication.mo diff --git a/src/mmoc/tests/system/gt_data/virus_replication/virus_replication.c b/src/mmoc/tests/system/gt_data/virus_replication/virus_replication.c new file mode 100644 index 00000000..f5598637 --- /dev/null +++ b/src/mmoc/tests/system/gt_data/virus_replication/virus_replication.c @@ -0,0 +1,429 @@ +#include +#include +#include +#include + +#include "virus_replication.h" +#include "pkg_math.h" +#include +#include +#include +#include +#include + +void MOD_settings(SD_simulationSettings settings) +{ + settings->debug = 0; + settings->parallel = FALSE; + settings->hybrid = TRUE; + settings->method = 0; + settings->random_seed = 1; +} + +void MOD_definition(int idx, double *x, double *d, double *a, double t, double *dx) +{ + int _d1; + int i; + switch(idx) { + case _eval_I(0): { + _der_I(0) = -_omega*(_I(0)-_mu)+_sigma*_dW/_h; + + + return; + } + case _eval_X(1,0): { + _der_X(1,0) = _I(0)-_k*_X(1,0); + + + return; + } + } + if (_is_var_X(idx)) { + _get_X_idxs(idx); + _apply_usage_eq_3(_d1); + if ((i >= 2 && i <= 10)) { + _der_X(i,0) = _k*_X(i-1,0)-_k*_X(i,0); + + + } + return; + } +} + +void MOD_zeroCrossing(int idx, double *x, double *d, double *a, double t, double *zc) +{ + int _d1; + int i; + if (_is_var_event_1(idx)) { + _get_event_1_idxs(idx); + _apply_usage_event_1(_d1); + if ((i >= 1 && i <= 10000)) { + _zc(0) = _time-(_TEvent(i)-_h); + + + } + return; + } +} + +void MOD_handlerPos(int idx, double *x, double* q, double *d, double *a, double t) +{ + int _d1; + int i; + if (_is_var_event_1(idx)) { + _get_event_1_idxs(idx); + _apply_usage_event_1(_d1); + if ((i >= 1 && i <= 10000)) { + _dW = _dWval(i); + } + 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) +{ + int _d1; + if (_is_var_out_exp_1(idx)) { + _get_out_exp_1_idxs(idx); + _apply_usage_out_exp_1(_d1); + if ((_d1 >= 1 && _d1 <= 10)) { + _out = _X(_d1,0); + } + return; + } +} + +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 <= 1; row++) { + c_row = _c_index(row); + x_ind = _idx_I(0); + col = pos(dvdx->df_dx[0]->index[c_row], dvdx->df_dx[0]->size[c_row], x_ind); + aux = 0; + dvdx->df_dx[0]->value[c_row][col] += aux; + } + for(row = 1; row <= 1; row++) { + c_row = _c_index(row); + x_ind = _idx_I(0); + col = pos(dvdx->df_dx[1]->index[c_row], dvdx->df_dx[1]->size[c_row], x_ind); + aux = 0; + dvdx->df_dx[1]->value[c_row][col] += aux; + x_ind = _idx_X(1,0); + col = pos(dvdx->df_dx[1]->index[c_row], dvdx->df_dx[1]->size[c_row], x_ind); + aux = 0; + dvdx->df_dx[1]->value[c_row][col] += aux; + } + for(row = 1; row <= 9; row++) { + c_row = _c_index(row); + _get_eq_3_var_idxs(row, eq_var); + _get_X_idxs(eq_var); + if((2 <= _d1 && _d1 <= 10)) { + x_ind = _idx_X(_d1,0); + col = pos(dvdx->df_dx[2]->index[c_row], dvdx->df_dx[2]->size[c_row], x_ind); + _apply_usage_eq_3(_d1); + aux = 0; + dvdx->df_dx[2]->value[c_row][col] += aux; + } + if((1 <= _d1-1 && _d1-1 <= 9)) { + x_ind = _idx_X(_d1-1,0); + col = pos(dvdx->df_dx[2]->index[c_row], dvdx->df_dx[2]->size[c_row], x_ind); + _apply_usage_eq_3(_d1); + aux = 0; + dvdx->df_dx[2]->value[c_row][col] += aux; + } + } + // Assign Jacobian Matrix values for equation: 0 + for (row = 0; row < 1; 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]); + } + } + // Assign Jacobian Matrix values for equation: 1 + for (row = 0; row < 1; row++) { + for (col = 0; col < dvdx->df_dx[1]->size[row]; col++) { + row_t = dvdx->df_dx[1]->index[row][col]; + _assign_jac(row_t, dvdx->df_dx[1]->value[row][col]); + } + } + // Assign Jacobian Matrix values for equation: 2 + for (row = 0; row < 9; row++) { + for (col = 0; col < dvdx->df_dx[2]->size[row]; col++) { + row_t = dvdx->df_dx[2]->index[row][col]; + _assign_jac(row_t, dvdx->df_dx[2]->value[row][col]); + } + } +} + +void MOD_dependencies(int idx, double *x, double *d, double *a, double t, double *dx, int *map) +{ + int _d1; + int i; + switch(idx) { + case _eval_I(0): { + _eval_dep_I(1) = -_omega*(_I(0)-_mu)+_sigma*_dW/_h; + _eval_dep_X(1,1) = _I(0)-_k*_X(1,0); + break; + } + case _eval_X(1,0): { + _eval_dep_X(1,1) = _I(0)-_k*_X(1,0); + break; + } + } + if (_is_var_X(idx)) { + _get_X_idxs(idx); + _apply_usage_eq_3(_d1); + if ((i >= 2 && i <= 10)) { + _eval_dep_X(i,1) = _k*_X(i-1,0)-_k*_X(i,0); + + } + } + if (_is_var_X(idx)) { + _get_X_idxs(idx); + _apply_usage_eq_3(_d1+1); + if ((i >= 2 && i <= 10)) { + _eval_dep_X(i,1) = _k*_X(i-1,0)-_k*_X(i,0); + + } + } +} + +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; + switch(idx) { + case _eval_I(0): { + _eval_dep_I(1) = -_omega*(_I(0)-_mu)+_sigma*_dW/_h; + + + continue; + } + case _eval_X(1,0): { + _eval_dep_X(1,1) = _I(0)-_k*_X(1,0); + + + continue; + } + } + if (_is_var_X(idx)) { + _get_X_idxs(idx); + _apply_usage_eq_3(_d1); + if ((i >= 2 && i <= 10)) { + _eval_dep_X(i,1) = _k*_X(i-1,0)-_k*_X(i,0); + + + } + continue; + } + } +} + +void QSS_initializeDataStructs(QSS_simulator simulator) +{ + simulator->data = QSS_Data(11,1,10000,0,0,3,0,"virus_replication"); + QSS_data modelData = simulator->data; + MODEL_DATA_ACCESS(modelData) + int* states = (int*) malloc(11*sizeof(int)); + int* discretes = (int*) malloc(1*sizeof(int)); + int* events = (int*) malloc(10000*sizeof(int)); + int* outputs = (int*) malloc(10*sizeof(int)); + int row, eq_var, c_row; + int x_ind; + int _d1; + int _rg_d1; + int i; + _init_I(0) = 0; + _di = 10000001/(double)10000; + _k = 1; + _mu = 1; + _omega = 1; + _sigma = 5.000000e-01; + _tf = 100; + _h = _tf/(double)10000; + _hmin = _tf/(double)10000001; + _W(1) = __math__normal(1); + for(i = 2; i<=10000001; i+=1) { + _W(i) = _W(i-1)+__math__normal(1)*sqrt(_hmin); + } + for(i = 1; i<=10000; i+=1) { + _dWval(i) = _W(i*_di+1)-_W((i-1)*_di+1); + _TEvent(i) = i*_h; + } + _dW = _dWval(1); + for(_d1 = 2; _d1<=10; _d1+=1) { + modelData->nSD[_idx_X(_d1,0)]++; + } + for(_d1 = 2; _d1<=10; _d1+=1) { + modelData->nSD[_idx_X(_d1-1,0)]++; + } + modelData->nSD[_idx_I(0)]++; + modelData->nSD[_idx_I(0)]++; + modelData->nSD[_idx_X(1,0)]++; + for(_d1 = 2; _d1<=10; _d1+=1) { + modelData->nDS[_idx_X(_d1,0)]++; + } + for(_d1 = 2; _d1<=10; _d1+=1) { + modelData->nDS[_idx_X(_d1,0)]++; + } + modelData->nDS[_idx_I(0)]++; + modelData->nDS[_idx_X(1,0)]++; + modelData->nDS[_idx_X(1,0)]++; + for(row = 1; row <= 1; row++) { + c_row = _c_index(row); + modelData->jac_matrices->df_dx[0]->size[c_row]++; + } + for(row = 1; row <= 1; row++) { + c_row = _c_index(row); + modelData->jac_matrices->df_dx[1]->size[c_row]++; + modelData->jac_matrices->df_dx[1]->size[c_row]++; + } + for(row = 1; row <= 9; row++) { + c_row = _c_index(row); + _get_eq_3_var_idxs(row, eq_var); + _get_X_idxs(eq_var); + if((2 <= _d1 && _d1 <= 10)) { + modelData->jac_matrices->df_dx[2]->size[c_row]++; + } + if((1 <= _d1-1 && _d1-1 <= 9)) { + modelData->jac_matrices->df_dx[2]->size[c_row]++; + } + } + for(_d1 = 1; _d1<=10000; _d1+=1) { + modelData->nHD[_idx_event_1(_d1)]++; + } + for(_d1 = 1; _d1<=10000; _d1+=1) { + modelData->event[_idx_event_1(_d1)].nLHSDsc++; + } + QSS_allocDataMatrix(modelData); + cleanVector(states, 0, 11); + for(_d1 = 2; _d1<=10; _d1+=1) { + modelData->SD[_idx_X(_d1,0)][states[_idx_X(_d1,0)]++] = _idx_X(_d1,0); + } + for(_d1 = 2; _d1<=10; _d1+=1) { + modelData->SD[_idx_X(_d1-1,0)][states[_idx_X(_d1-1,0)]++] = _idx_X(_d1,0); + } + modelData->SD[_idx_I(0)][states[_idx_I(0)]++] = _idx_I(0); + modelData->SD[_idx_I(0)][states[_idx_I(0)]++] = _idx_X(1,0); + modelData->SD[_idx_X(1,0)][states[_idx_X(1,0)]++] = _idx_X(1,0); + cleanVector(states, 0, 11); + for(_d1 = 2; _d1<=10; _d1+=1) { + modelData->DS[_idx_X(_d1,0)][states[_idx_X(_d1,0)]++] = _idx_X(_d1,0); + } + for(_d1 = 2; _d1<=10; _d1+=1) { + modelData->DS[_idx_X(_d1,0)][states[_idx_X(_d1,0)]++] = _idx_X(_d1-1,0); + } + modelData->DS[_idx_I(0)][states[_idx_I(0)]++] = _idx_I(0); + modelData->DS[_idx_X(1,0)][states[_idx_X(1,0)]++] = _idx_I(0); + modelData->DS[_idx_X(1,0)][states[_idx_X(1,0)]++] = _idx_X(1,0); + cleanVector(states, 0, 11); + for(row = 1; row <= 1; row++) { + c_row = _c_index(row); + x_ind = _idx_I(0); + if(in(modelData->jac_matrices->df_dx[0]->index[c_row],modelData->jac_matrices->df_dx[0]->size[c_row], x_ind)){ + modelData->jac_matrices->df_dx[0]->size[c_row]--; + } else { + modelData->jac_matrices->df_dx[0]->index[c_row][states[c_row]++] = x_ind; + } + } + cleanVector(states, 0, 11); + for(row = 1; row <= 1; row++) { + c_row = _c_index(row); + x_ind = _idx_I(0); + if(in(modelData->jac_matrices->df_dx[1]->index[c_row],modelData->jac_matrices->df_dx[1]->size[c_row], x_ind)){ + modelData->jac_matrices->df_dx[1]->size[c_row]--; + } else { + modelData->jac_matrices->df_dx[1]->index[c_row][states[c_row]++] = x_ind; + } + x_ind = _idx_X(1,0); + if(in(modelData->jac_matrices->df_dx[1]->index[c_row],modelData->jac_matrices->df_dx[1]->size[c_row], x_ind)){ + modelData->jac_matrices->df_dx[1]->size[c_row]--; + } else { + modelData->jac_matrices->df_dx[1]->index[c_row][states[c_row]++] = x_ind; + } + } + cleanVector(states, 0, 11); + for(row = 1; row <= 9; row++) { + c_row = _c_index(row); + _get_eq_3_var_idxs(row, eq_var); + _get_X_idxs(eq_var); + if((2 <= _d1 && _d1 <= 10)) { + x_ind = _idx_X(_d1,0); + if(in(modelData->jac_matrices->df_dx[2]->index[c_row],modelData->jac_matrices->df_dx[2]->size[c_row], x_ind)){ + modelData->jac_matrices->df_dx[2]->size[c_row]--; + } else { + modelData->jac_matrices->df_dx[2]->index[c_row][states[c_row]++] = x_ind; + } + } + if((1 <= _d1-1 && _d1-1 <= 9)) { + x_ind = _idx_X(_d1-1,0); + if(in(modelData->jac_matrices->df_dx[2]->index[c_row],modelData->jac_matrices->df_dx[2]->size[c_row], x_ind)){ + modelData->jac_matrices->df_dx[2]->size[c_row]--; + } else { + modelData->jac_matrices->df_dx[2]->index[c_row][states[c_row]++] = x_ind; + } + } + } + cleanVector(events, 0, 10000); + for(_d1 = 1; _d1<=10000; _d1+=1) { + modelData->HD[_idx_event_1(_d1)][events[_idx_event_1(_d1)]++] = _idx_I(0); + } + cleanVector(events, 0, 10000); + for(_d1 = 1; _d1<=10000; _d1+=1) { + modelData->event[_idx_event_1(_d1)].LHSDsc[events[_idx_event_1(_d1)]++] = _idx_dW; + } + for(i = 1; i<=10000; i+=1) { + modelData->event[_idx_event_1(i)].direction = 1; + modelData->event[_idx_event_1(i)].relation = 2; + } + SD_setupJacMatrices(modelData->jac_matrices); + simulator->time = QSS_Time(11,10000,0,0,ST_Binary, NULL); + double period[1]; + period[0] = 0.1; + simulator->output = SD_Output("virus_replication",10,1,11,period,1,0,CI_Sampled,SD_Memory,MOD_output); + SD_output modelOutput = simulator->output; + for(_d1 = 1; _d1<=10; _d1+=1) { + modelOutput->nOS[_idx_out_exp_1(_d1)]++; + } + for(_d1 = 1; _d1<=10; _d1+=1) { + modelOutput->nSO[_idx_X(_d1,0)]++; + } + SD_allocOutputMatrix(modelOutput, 11, 1); + for(_d1 = 1; _d1<=10; _d1+=1) { + sprintf(modelOutput->variable[_idx_out_exp_1(_d1)].name, "X[%d]",_d1); + } + cleanVector(outputs, 0, 10); + for(_d1 = 1; _d1<=10; _d1+=1) { + modelOutput->OS[_idx_out_exp_1(_d1)][outputs[_idx_out_exp_1(_d1)]++] = _idx_X(_d1,0); + } + cleanVector(states, 0, 11); + for(_d1 = 1; _d1<=10; _d1+=1) { + modelOutput->SO[_idx_X(_d1,0)][states[_idx_X(_d1,0)]++] = _idx_out_exp_1(_d1); + } + 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); + free(outputs); +} + +void CLC_initializeDataStructs(CLC_simulator simulator) +{ +} + diff --git a/src/mmoc/tests/system/gt_data/virus_replication/virus_replication.h b/src/mmoc/tests/system/gt_data/virus_replication/virus_replication.h new file mode 100644 index 00000000..cf4eb202 --- /dev/null +++ b/src/mmoc/tests/system/gt_data/virus_replication/virus_replication.h @@ -0,0 +1,162 @@ +// 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: I +#define _idx_I(coeff) 0 +#define _state_idx_I(coeff) 0*2 + coeff +#define _I(coeff) x[_state_idx_I(coeff)] * COEFF_MULTIPLIER(coeff) +#define _init_I(coeff) x[_state_idx_I(coeff)] +#define _q_I(coeff) q[_state_idx_I(coeff)] * COEFF_MULTIPLIER(coeff) +#define _eval_I(coeff) 0 +#define _eval_dep_I(coeff) dx[_state_idx_I(coeff)] + +// Macros definition for variable: TEvent +#define _idx_TEvent(d1) ((d1-1)) +#define _TEvent(d1) __PAR__TEvent[_idx_TEvent(d1)] + +// Macros definition for variable: W +#define _idx_W(d1) ((d1-1)) +#define _W(d1) __PAR__W[_idx_W(d1)] + +// Macros definition for variable: X +#define _idx_X(d1,coeff) (1+(d1-1)) +#define _state_idx_X(d1,coeff) (1+(d1-1))*2 + coeff +#define _X(d1,coeff) x[_state_idx_X(d1,coeff)] * COEFF_MULTIPLIER(coeff) +#define _init_X(d1,coeff) x[_state_idx_X(d1,coeff)] +#define _q_X(d1,coeff) q[_state_idx_X(d1,coeff)] * COEFF_MULTIPLIER(coeff) +#define _eval_X(d1,coeff) (1+(d1-1)) +#define _is_var_X(idx) idx >= 1 && idx < 11 +#define _get_X_idxs(idx)\ + _d1 = (idx-1)+ 1; +#define _eval_dep_X(d1,coeff) dx[_state_idx_X(d1,coeff)] + +// Macros definition for variable: _event_1 +#define _idx_event_1(d1) ((d1-1)) +#define _eval_event_1(d1) ((d1-1)) +#define _is_var_event_1(idx) idx >= 0 && idx < 10000 +#define _get_event_1_idxs(idx)\ + _d1 = (idx)+ 1; + +// Macros definition for variable: _out_exp_1 +#define _idx_out_exp_1(d1) ((d1-1)) +#define _eval_out_exp_1(d1) ((d1-1)) +#define _is_var_out_exp_1(idx) idx >= 0 && idx < 10 +#define _get_out_exp_1_idxs(idx)\ + _d1 = (idx)+ 1; + +// Macros definition for variable: dW +#define _idx_dW 0 +#define _dW d[_idx_dW] + +// Macros definition for variable: dWval +#define _idx_dWval(d1) ((d1-1)) +#define _dWval(d1) __PAR__dWval[_idx_dWval(d1)] + +// Macros definition for variable: di +#define _di __PAR__di + +// Macros definition for variable: h +#define _h __PAR__h + +// Macros definition for variable: hmin +#define _hmin __PAR__hmin + +// Macros definition for variable: k +#define _k __PAR__k + +// Macros definition for variable: mu +#define _mu __PAR__mu + +// Macros definition for variable: omega +#define _omega __PAR__omega + +// Macros definition for variable: sigma +#define _sigma __PAR__sigma + +// Macros definition for variable: tf +#define _tf __PAR__tf + + +// Model Parameters Declaration + +// Macro for parameter: TEvent +double __PAR__TEvent[10000]; +// Macro for parameter: W +double __PAR__W[10000001]; +// Macro for parameter: dWval +double __PAR__dWval[10000]; +// Macro for parameter: di +int __PAR__di; +// Macro for parameter: h +double __PAR__h; +// Macro for parameter: hmin +double __PAR__hmin; +// Macro for parameter: k +double __PAR__k; +// Macro for parameter: mu +double __PAR__mu; +// Macro for parameter: omega +double __PAR__omega; +// Macro for parameter: sigma +double __PAR__sigma; +// Macro for parameter: tf +double __PAR__tf; + +// Derivative Equations Macros + +// Macros for equation: 1 + +// Macros for equation: 2 + +// Macros for equation: 3 +#define _apply_usage_eq_3(_d1) \ + i = _d1; +#define _get_eq_3_var_idxs(row, var)\ + _rg_d1 = 1 + (row-1)+ 1;\ + var = _idx_X(_rg_d1,0); + +// Event Macros + +// Macros for event: 1 +#define _apply_usage_event_1(_d1) \ + i = _d1; +#define _get_event_1_var_idxs(row, var)\ + _rg_d1 = 0 + (row-1)+ 1;\ + var = _idx_event_1(_rg_d1); +#define _zc(coeff) zc[coeff] + +// Output Equations Macros + +// Macros for output equation: 1 +#define _apply_usage_out_exp_1(_d1) \ + _d1 = _d1; +#define _get_out_exp_1_var_idxs(row, var)\ + _rg_d1 = 0 + (row-1)+ 1;\ + var = _idx_out_exp_1(_rg_d1); +#define _out out[0] + +// 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: I +#define _der_I(coeff) dx[coeff+1] +// Derivative definition for variable: X +#define _der_X(d1,coeff) dx[coeff+1] diff --git a/src/mmoc/tests/system/gt_data/virus_replication/virus_replication.ini b/src/mmoc/tests/system/gt_data/virus_replication/virus_replication.ini new file mode 100644 index 00000000..eafc40ad --- /dev/null +++ b/src/mmoc/tests/system/gt_data/virus_replication/virus_replication.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+02; +sol="QSS"; +dqmin=(1.00000e-02); +dqrel=(0.00000e+00); +bdf=0; +BDFPartitionDepth=1; +BDFMaxStep=0.00000e+00; diff --git a/src/mmoc/tests/system/gt_data/virus_replication/virus_replication.mo b/src/mmoc/tests/system/gt_data/virus_replication/virus_replication.mo new file mode 100644 index 00000000..95faae30 --- /dev/null +++ b/src/mmoc/tests/system/gt_data/virus_replication/virus_replication.mo @@ -0,0 +1,65 @@ +model virus_replication + import math; + constant Integer N=10; +constant Integer M=10000; //number of samples +constant Integer SizeW=10000001; + Real I(start=0), X[N]; // random input , concentration of material in compartment i + parameter Real mu=1, sigma=0.5, omega=1; // mean, noise magnitude , reversion strength of the Ornstein-Uhlenbeck process +parameter Real tf=100; +parameter Real k=1; +parameter Real h(fixed=false); //progression rate of material from one compartment to the nex + discrete Real dW; +parameter Real W[SizeW](each fixed=false); +parameter Real dWval[M](each fixed=false); +parameter Real TEvent[M]; +parameter Integer di=SizeW/M; +parameter Real hmin(fixed=false); + +initial algorithm +h:=tf/M; +hmin:=tf/SizeW; +W[1]:=normal(1); +for i in 2:SizeW loop + W[i]:=W[i-1]+normal(1)*sqrt(hmin); //generate wiener process samples with dt=1e-4 +end for; +for i in 1:M loop + dWval[i]:=W[i*di+1]-W[(i-1)*di+1]; //compute the random increments + TEvent[i]:=i*h; + end for; +dW:=dWval[1]; + +equation + +der(I)=-omega*(I-mu)+sigma*dW/h; +der(X[1]) =I-k*X[1]; + +for i in 2:N loop + der(X[i])=k*X[i-1] - k*X[i]; +end for; + +algorithm + +for i in 1:M loop + when time>TEvent[i]-h then + dW:=dWval[i]; + end when; +end for; + annotation( + + experiment( + MMO_Description="", + MMO_Solver=QSS, + MMO_Period={100/1000}, + MMO_PartitionMethod=Metis, + MMO_Output={X}, + MMO_OutputType=CI_Sampled, + Jacobian=Dense, + MMO_BDF_PDepth=1, + MMO_BDF_Max_Step=0, + MMO_RandomSeed=1, + StartTime=0.0, + StopTime=100, + Tolerance={0}, + AbsTolerance={1e-2} + )); +end virus_replication; diff --git a/src/mmoc/tests/system/models_test.cpp b/src/mmoc/tests/system/models_test.cpp index 0952e689..84b2f572 100644 --- a/src/mmoc/tests/system/models_test.cpp +++ b/src/mmoc/tests/system/models_test.cpp @@ -56,44 +56,13 @@ TEST_P(IModelTests, GenerateCode) EXPECT_TRUE(result.good()); } -const char* models[] = {"adr", - "adr2D", - "advection", - "advection2D", - "advection2D_LI", - "advection_quoted", - "advectionFlux", - "airconds", - "aircont", - "bball_downstairs", - "boost", - "BouncingBall", - "buck", - "buckboost", - "buck_circuit", - "buck_term", - "burgers", - "cuk", - "cuk2", - "interleaved", - "inverters", - "lc_line", - "lotka_volterra", - "mliqss_adr", - "mliqss_buck", - "mliqss_test", - "mliqss_TYSON", - "NeuralNetwork1", - "par_airconds", - "par_airconds_cont", - "rectifier", - "rltest", - "rltest_LI", - "spikings", - "testFor", - "test_input", - "TYSON", - "VIRplanoS"}; +const char* models[] = {"adr", "adr2D", "advection", "advection2D", "advection2D_LI", "advection_quoted", + "advectionFlux", "airconds", "aircont", "bball_downstairs", "boost", "BouncingBall", + "buck", "buckboost", "buck_circuit", "buck_term", "burgers", "cuk", + "cuk2", "interleaved", "inverters", "lc_line", "lotka_volterra", "mliqss_adr", + "mliqss_buck", "mliqss_test", "mliqss_TYSON", "NeuralNetwork1", "par_airconds", "par_airconds_cont", + "rectifier", "rltest", "rltest_LI", "spikings", "testFor", "test_input", + "TYSON", "VIRplanoS", "virus_replication"}; INSTANTIATE_TEST_SUITE_P(Models, IModelTests, testing::ValuesIn(models));