Added initi code time test.

src/mmoc/tests/system/gt_data/init_code_time/init_code_time.c

@@ -0,0 +1,144 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+
+#include "init_code_time.h"
+#include <common/utils.h>
+#include <common/model.h>
+#include <common/commands.h>
+#include <qss/qss_model.h>
+#include <classic/classic_model.h>
+
+void MOD_settings(SD_simulationSettings settings)
+{
+	settings->debug = 0;
+	settings->parallel = FALSE;
+	settings->hybrid = FALSE;
+	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)
+{
+}
+
+void MOD_handlerPos(int idx, double *x, double* q, double *d, double *a, double t)
+{
+}
+
+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,0,0,1000,0,1,0,"init_code_time");
+	QSS_data modelData = simulator->data;
+	MODEL_DATA_ACCESS(modelData)
+	int* states = (int*) malloc(1000*sizeof(int));
+	int row, eq_var, c_row;
+	int x_ind;
+	int _d1;
+	int _rg_d1;
+	int i;
+	int t = 0;
+	for(i = 1; i<=999; i+=1) {
+		_init_u(i,0) = _time;
+	}
+	_init_u(1000,0) = _time;
+	for(row = 1; row <= 1000; row++) {
+		c_row = _c_index(row);
+		_get_eq_1_var_idxs(row, eq_var);
+		_get_u_idxs(eq_var);
+	}
+	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);
+	}
+	SD_setupJacMatrices(modelData->jac_matrices);
+	simulator->time = QSS_Time(1000,0,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("init_code_time",0,0,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);
+}
+
+void CLC_initializeDataStructs(CLC_simulator simulator)
+{
+}
+

src/mmoc/tests/system/gt_data/init_code_time/init_code_time.h

@@ -0,0 +1,51 @@
+// Model data access macro.
+
+#define MODEL_DATA_ACCESS(m) \
+  double* x = m->x; 
+
+// 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: 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);
+
+// 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]

src/mmoc/tests/system/gt_data/init_code_time/init_code_time.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;

src/mmoc/tests/system/gt_data/init_code_time/init_code_time.mo

@@ -0,0 +1,30 @@
+model init_code_time
+  constant Integer N=1000;
+  Real u[N];
+
+initial algorithm
+  for i in 1:N-1 loop 
+     u[i]:=time; 
+  end for;
+  u[N]:= time;
+
+equation
+  for i in 1:N loop
+    der(u[i])=time;
+  end for;
+	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 init_code_time;

src/mmoc/tests/system/models_test.cpp

@@ -56,13 +56,47 @@ TEST_P(IModelTests, GenerateCode)
   EXPECT_TRUE(result.good());
 }
 
-const char* models[] = {"adr",           "adr2D",       "advection",        "advection2D",      "advection2D_LI", "advection_quoted",
-                        "advectionFlux", "airconds",    "aircont",          "allow_discrete_integer", "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"};
+const char* models[] = {"adr",
+                        "adr2D",
+                        "advection",
+                        "advection2D",
+                        "advection2D_LI",
+                        "advection_quoted",
+                        "advectionFlux",
+                        "airconds",
+                        "aircont",
+                        "allow_discrete_integer",
+                        "bball_downstairs",
+                        "boost",
+                        "BouncingBall",
+                        "buck",
+                        "buckboost",
+                        "buck_circuit",
+                        "buck_term",
+                        "burgers",
+                        "cuk",
+                        "cuk2",
+                        "init_code_time",
+                        "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));
 
 /// @}