def __init__(self, path_rendered, dpkgRoot, dpkg, **kwargs): Ccoder.__init__(self, dpkgRoot, dpkg, **kwargs) Data.__init__(self, path_rendered, dpkgRoot, dpkg, **kwargs) self.path_rendered = os.path.abspath(unicode(path_rendered, 'utf8')) self.env = Environment(loader=FileSystemLoader(os.path.join(self.path_rendered, 'C', 'templates'))) self.env.filters.update({ 'is_prior': lambda x: ('require' in x) and ('fields' not in x['require']) and ('data' in x) and ('distribution' in x['data']) })
def __init__(self, path_rendered, dpkgRoot, dpkg, **kwargs): Ccoder.__init__(self, dpkgRoot, dpkg, **kwargs) Data.__init__(self, path_rendered, dpkgRoot, dpkg, **kwargs) self.path_rendered = os.path.abspath(unicode(path_rendered, 'utf8')) self.env = Environment(loader=FileSystemLoader(os.path.join(self.path_rendered, 'C', 'templates'))) self.env.filters.update({ 'is_prior': lambda x: ('data' in x) and isinstance(x['data'], dict) and ('data' in x['data']) and ('distribution' in x['data']['data']) })
def __init__(self, path_rendered, dpkgRoot, dpkg, **kwargs): Ccoder.__init__(self, dpkgRoot, dpkg, **kwargs) self.starts = [parse_date(x['start']) for x in self.obs_model] self.t0 = min(self.starts) try: #the .data.json contains all the data and metadata comming from the data package and it's dependencies' self._data = json.load(open(os.path.join(path_rendered,'.data.json'))) except ValueError, IOError: raise DataError('could not process .data.json')
def __init__(self, path_rendered, dpkgRoot, dpkg, **kwargs): path_rendered = unicode(path_rendered, 'utf8') Ccoder.__init__(self, dpkgRoot, dpkg, **kwargs) self.starts = [parse_date(x['start']) for x in self.obs_model] self.t0 = min(self.starts) try: #the .data.json contains all the data and metadata comming from the data package and it's dependencies' self._data = json.load( open(os.path.join(path_rendered, '.data.json'))) except ValueError, IOError: raise DataError('could not process .data.json')
def __init__(self, path_rendered, context, process, link): Context.__init__(self, context) Ccoder.__init__(self, context, process, link) self.path_rendered = path_rendered ##map_ts_obs self.map_ts_obs = {} for x in link['observed']: for ts in x['time_series_id']: self.map_ts_obs[ts] = x['id'] ########################## ##sort context ########################## #tbs: to be sorted tbs = zip(self.ts_id, self._repeated_name_stream, self._repeated_name_ts) #sort by data_stream tbs.sort(key=lambda x: x[1]) #sort by name_ts (in python, sorts are guaranteed to be stable) tbs.sort(key=lambda x: x[2]) #sort by obs_var (in python, sorts are guaranteed to be stable) tbs.sort(key=lambda x: self.obs_var.index(self.map_ts_obs[ x[0] ])) #we need to sort ts_id, _repeated_name_ts, _repeated_name_stream, _repeated_obs_type, data and all the par_fixed involved in the obs_model ind_sorted = [ self.ts_id.index(x[0]) for x in tbs ] self.ts_id = [ self.ts_id[x] for x in ind_sorted ] self._repeated_name_ts = [self._repeated_name_ts[x] for x in ind_sorted] self._repeated_name_stream = [self._repeated_name_stream[x] for x in ind_sorted] self._repeated_obs_type = [self._repeated_obs_type[x] for x in ind_sorted] #data if self.data: self.data = [ [ y[x] for x in ind_sorted ] for y in self.data ]
def setUp(self): c = json.load(open(os.path.join('example', 'drift', 'context.json'))) p = json.load(open(os.path.join('example', 'drift', 'process.json'))) l = json.load(open(os.path.join('example', 'drift', 'link.json'))) self.m_drift = Ccoder(c, p, l) c = json.load(open(os.path.join('example', 'noise', 'context.json'))) p = json.load(open(os.path.join('example', 'noise', 'process.json'))) l = json.load(open(os.path.join('example', 'noise', 'link.json'))) self.m_noise = Ccoder(c, p, l) p = json.load(open(os.path.join('example', 'noise', 'process.json'))) p["white_noise"][0]["reaction"][0] = {'to':'S','from':'U'} self.m_noise2 = Ccoder(c, p, l) p = json.load(open(os.path.join('example', 'noise', 'process.json'))) p["white_noise"][0]["reaction"][0] = {'to':'R','from':'I'} self.m_noise3 = Ccoder(c, p, l) p = json.load(open(os.path.join('example', 'noise', 'process.json'))) p["white_noise"][0]["reaction"][0] = {'to':'U','from':'I'} self.m_noise4 = Ccoder(c, p, l) p = json.load(open(os.path.join('example', 'noise', 'process.json'))) p["model"].append({"from": "R", "to": "U", "rate": "mu_d", "comment":"death"}) p["white_noise"][0]["reaction"][0] = {'to':'U','from':'R'} self.m_noise5 = Ccoder(c, p, l) p = json.load(open(os.path.join('example', 'noise', 'process.json'))) p["white_noise"][0]["reaction"].append({'to':'R','from':'I'}) self.m_noise6 = Ccoder(c, p, l) p = json.load(open(os.path.join('example', 'noise', 'process.json'))) p["white_noise"].append({"reaction":[{'to':'R','from':'I'}],"sd":"sto"}) self.m_noise7 = Ccoder(c, p, l) p = json.load(open(os.path.join('example', 'drift', 'process.json'))) p["model"].append({"from": "R", "to": "I", "rate": "correct_rate(v)", "comment":"testing"}) self.m_drift2 = Ccoder(c, p, l)
def setUp(self): shutil.copytree(os.path.join('..', 'examples', 'noise'), os.path.join('..', 'examples', '__tmp_noise')) dpkgRoot = os.path.join('..', 'examples', 'noise') dpkg = json.load(open(os.path.join(dpkgRoot, 'package.json'))) self.m_noise = Ccoder(dpkgRoot, copy.deepcopy(dpkg)) m_diff = copy.deepcopy(dpkg) del m_diff['model']['reactions'][2]['white_noise'] del m_diff['model']['reactions'][3]['white_noise'] m_diff['model']['sde'] = { 'drift': [{ 'name': 'r0_paris', 'f': 0.0, 'transformation': 'log(r0_paris)' }, { 'name': 'r0_nyc', 'f': 0.0, 'transformation': 'log(r0_nyc)' }], 'dispertion': [['vol', 0], [0, 'vol']] } self.m_diff = Ccoder(dpkgRoot, m_diff) m_noise2 = copy.deepcopy(dpkg) del m_noise2['model']['reactions'][2]['white_noise'] del m_noise2['model']['reactions'][3]['white_noise'] m_noise2['model']['reactions'][0]['white_noise'] = { 'name': 'noise_SI', 'sd': 'sto' } m_noise2['model']['reactions'][1]['white_noise'] = { 'name': 'noise_SI2', 'sd': 'sto' } self.m_noise2 = Ccoder(dpkgRoot, m_noise2) m_noise3 = copy.deepcopy(dpkg) del m_noise3['model']['reactions'][2]['white_noise'] del m_noise3['model']['reactions'][3]['white_noise'] m_noise3['model']['reactions'][4]['white_noise'] = { 'name': 'noise_SI', 'sd': 'sto' } m_noise3['model']['reactions'][5]['white_noise'] = { 'name': 'noise_SI2', 'sd': 'sto' } self.m_noise3 = Ccoder(dpkgRoot, m_noise3) m_noise4 = copy.deepcopy(dpkg) del m_noise4['model']['reactions'][2]['white_noise'] del m_noise4['model']['reactions'][3]['white_noise'] m_noise4['model']['reactions'][8]['white_noise'] = { 'name': 'noise_SI', 'sd': 'sto' } m_noise4['model']['reactions'][9]['white_noise'] = { 'name': 'noise_SI2', 'sd': 'sto' } self.m_noise4 = Ccoder(dpkgRoot, m_noise4) m_noise5 = copy.deepcopy(dpkg) del m_noise5['model']['reactions'][2]['white_noise'] del m_noise5['model']['reactions'][3]['white_noise'] m_noise5['model']['reactions'][10]['white_noise'] = { 'name': 'noise_SI', 'sd': 'sto' } m_noise5['model']['reactions'][11]['white_noise'] = { 'name': 'noise_SI2', 'sd': 'sto' } self.m_noise5 = Ccoder(dpkgRoot, m_noise5) m_noise6 = copy.deepcopy(dpkg) m_noise6['model']['reactions'][4]['white_noise'] = { 'name': 'noise_SI', 'sd': 'sto' } m_noise6['model']['reactions'][5]['white_noise'] = { 'name': 'noise_SI2', 'sd': 'sto' } self.m_noise6 = Ccoder(dpkgRoot, m_noise6) m_noise7 = copy.deepcopy(dpkg) m_noise7['model']['reactions'][4]['white_noise'] = { 'name': 'noise_SI23', 'sd': 'sto' } m_noise7['model']['reactions'][5]['white_noise'] = { 'name': 'noise_SI24', 'sd': 'sto' } self.m_noise7 = Ccoder(dpkgRoot, m_noise7) m_diff2 = copy.deepcopy(dpkg) del m_diff2['model']['reactions'][2]['white_noise'] del m_diff2['model']['reactions'][3]['white_noise'] m_diff2['model']['sde'] = copy.deepcopy(m_diff['model']['sde']) m_diff2['model']['reactions'].append({ 'from': 'R_paris', 'to': 'I_paris', 'rate': 'correct_rate(v)', 'description': 'testing' }) m_diff2['model']['reactions'].append({ 'from': 'R_nyc', 'to': 'I_nyc', 'rate': 'correct_rate(v)', 'description': 'testing' }) self.m_diff2 = Ccoder(dpkgRoot, m_diff2)
class TestCcoder(unittest.TestCase): def setUp(self): shutil.copytree(os.path.join('..', 'examples', 'noise'), os.path.join('..', 'examples', '__tmp_noise')) dpkgRoot = os.path.join('..', 'examples', 'noise') dpkg = json.load(open(os.path.join(dpkgRoot, 'package.json'))) self.m_noise = Ccoder(dpkgRoot, copy.deepcopy(dpkg)) m_diff = copy.deepcopy(dpkg) del m_diff['model']['reactions'][2]['white_noise'] del m_diff['model']['reactions'][3]['white_noise'] m_diff['model']['sde'] = { 'drift': [{ 'name': 'r0_paris', 'f': 0.0, 'transformation': 'log(r0_paris)' }, { 'name': 'r0_nyc', 'f': 0.0, 'transformation': 'log(r0_nyc)' }], 'dispertion': [['vol', 0], [0, 'vol']] } self.m_diff = Ccoder(dpkgRoot, m_diff) m_noise2 = copy.deepcopy(dpkg) del m_noise2['model']['reactions'][2]['white_noise'] del m_noise2['model']['reactions'][3]['white_noise'] m_noise2['model']['reactions'][0]['white_noise'] = { 'name': 'noise_SI', 'sd': 'sto' } m_noise2['model']['reactions'][1]['white_noise'] = { 'name': 'noise_SI2', 'sd': 'sto' } self.m_noise2 = Ccoder(dpkgRoot, m_noise2) m_noise3 = copy.deepcopy(dpkg) del m_noise3['model']['reactions'][2]['white_noise'] del m_noise3['model']['reactions'][3]['white_noise'] m_noise3['model']['reactions'][4]['white_noise'] = { 'name': 'noise_SI', 'sd': 'sto' } m_noise3['model']['reactions'][5]['white_noise'] = { 'name': 'noise_SI2', 'sd': 'sto' } self.m_noise3 = Ccoder(dpkgRoot, m_noise3) m_noise4 = copy.deepcopy(dpkg) del m_noise4['model']['reactions'][2]['white_noise'] del m_noise4['model']['reactions'][3]['white_noise'] m_noise4['model']['reactions'][8]['white_noise'] = { 'name': 'noise_SI', 'sd': 'sto' } m_noise4['model']['reactions'][9]['white_noise'] = { 'name': 'noise_SI2', 'sd': 'sto' } self.m_noise4 = Ccoder(dpkgRoot, m_noise4) m_noise5 = copy.deepcopy(dpkg) del m_noise5['model']['reactions'][2]['white_noise'] del m_noise5['model']['reactions'][3]['white_noise'] m_noise5['model']['reactions'][10]['white_noise'] = { 'name': 'noise_SI', 'sd': 'sto' } m_noise5['model']['reactions'][11]['white_noise'] = { 'name': 'noise_SI2', 'sd': 'sto' } self.m_noise5 = Ccoder(dpkgRoot, m_noise5) m_noise6 = copy.deepcopy(dpkg) m_noise6['model']['reactions'][4]['white_noise'] = { 'name': 'noise_SI', 'sd': 'sto' } m_noise6['model']['reactions'][5]['white_noise'] = { 'name': 'noise_SI2', 'sd': 'sto' } self.m_noise6 = Ccoder(dpkgRoot, m_noise6) m_noise7 = copy.deepcopy(dpkg) m_noise7['model']['reactions'][4]['white_noise'] = { 'name': 'noise_SI23', 'sd': 'sto' } m_noise7['model']['reactions'][5]['white_noise'] = { 'name': 'noise_SI24', 'sd': 'sto' } self.m_noise7 = Ccoder(dpkgRoot, m_noise7) m_diff2 = copy.deepcopy(dpkg) del m_diff2['model']['reactions'][2]['white_noise'] del m_diff2['model']['reactions'][3]['white_noise'] m_diff2['model']['sde'] = copy.deepcopy(m_diff['model']['sde']) m_diff2['model']['reactions'].append({ 'from': 'R_paris', 'to': 'I_paris', 'rate': 'correct_rate(v)', 'description': 'testing' }) m_diff2['model']['reactions'].append({ 'from': 'R_nyc', 'to': 'I_nyc', 'rate': 'correct_rate(v)', 'description': 'testing' }) self.m_diff2 = Ccoder(dpkgRoot, m_diff2) def tearDown(self): shutil.rmtree(os.path.join('..', 'examples', '__tmp_noise')) def test_eval_Q(self): calc_Q = self.m_noise.eval_Q() # testing env sto only # order: I_nyc, I_paris, S_nyc, S_paris, inc_all , inc_nyc term_paris = '((((r0_paris/N_paris*v*I_paris)*S_paris)*((sto)**2))*((r0_paris/N_paris*v*I_paris)*S_paris)))' term_nyc = '((((r0_nyc/N_nyc*v*I_nyc)*S_nyc)*((sto)**2))*((r0_nyc/N_nyc*v*I_nyc)*S_nyc)))' Q_cm = calc_Q["no_dem_sto"]["Q_cm"] self.assertEqual(Q_cm[0][0], '((1)*' + term_nyc + '*(1)') self.assertEqual(Q_cm[0][1], 0) self.assertEqual(Q_cm[0][2], '((1)*' + term_nyc + '*(-1)') self.assertEqual(Q_cm[0][3], 0) self.assertEqual(Q_cm[0][4], 0) self.assertEqual(Q_cm[0][5], '((1)*' + term_nyc + '*(1)') self.assertEqual(Q_cm[1][0], 0) self.assertEqual(Q_cm[1][1], '((1)*' + term_paris + '*(1)') self.assertEqual(Q_cm[1][2], 0) self.assertEqual(Q_cm[1][3], '((1)*' + term_paris + '*(-1)') self.assertEqual(Q_cm[1][4], 0) self.assertEqual(Q_cm[1][5], 0) self.assertEqual(Q_cm[2][0], '((-1)*' + term_nyc + '*(1)') self.assertEqual(Q_cm[2][1], 0) self.assertEqual(Q_cm[2][2], '((-1)*' + term_nyc + '*(-1)') self.assertEqual(Q_cm[2][3], 0) self.assertEqual(Q_cm[2][4], 0) self.assertEqual(Q_cm[2][5], '((-1)*' + term_nyc + '*(1)') self.assertEqual(Q_cm[3][0], 0) self.assertEqual(Q_cm[3][1], '((-1)*' + term_paris + '*(1)') self.assertEqual(Q_cm[3][2], 0) self.assertEqual(Q_cm[3][3], '((-1)*' + term_paris + '*(-1)') self.assertEqual(Q_cm[3][4], 0) self.assertEqual(Q_cm[3][5], 0) self.assertEqual(Q_cm[4][0], 0) self.assertEqual(Q_cm[4][1], 0) self.assertEqual(Q_cm[4][2], 0) self.assertEqual(Q_cm[4][3], 0) self.assertEqual(Q_cm[4][4], 0) self.assertEqual(Q_cm[4][5], 0) self.assertEqual(Q_cm[5][0], '((1)*' + term_nyc + '*(1)') self.assertEqual(Q_cm[5][1], 0) self.assertEqual(Q_cm[5][2], '((1)*' + term_nyc + '*(-1)') self.assertEqual(Q_cm[5][3], 0) self.assertEqual(Q_cm[5][4], 0) self.assertEqual(Q_cm[5][5], '((1)*' + term_nyc + '*(1)') # testing dem sto only term1_p = '(mu_b_paris*N_paris))' term2_p = '((r0_paris/N_paris*v*I_paris)*S_paris))' term3_p = '((correct_rate(v))*I_paris))' term4_p = '((mu_d_paris)*S_paris))' term5_p = '((mu_d_paris)*I_paris))' term1_n = '(mu_b_nyc*N_nyc))' term2_n = '((r0_nyc/N_nyc*v*I_nyc)*S_nyc))' term3_n = '((correct_rate(v))*I_nyc))' term4_n = '((mu_d_nyc)*S_nyc))' term5_n = '((mu_d_nyc)*I_nyc))' # order: I_nyc, I_paris, S_nyc, S_paris, inc_all , inc_nyc Q_cm = calc_Q["no_env_sto"]["Q_cm"] self.assertEqual( Q_cm[0][0], '((1)*' + term2_n + '*(1) + ((-1)*' + term3_n + '*(-1) + ((-1)*' + term5_n + '*(-1)') self.assertEqual(Q_cm[0][1], 0) self.assertEqual(Q_cm[0][2], '((1)*' + term2_n + '*(-1)') self.assertEqual(Q_cm[0][3], 0) self.assertEqual( Q_cm[0][4], '((-1)*' + term3_n + '*(1) + ((-1)*' + term5_n + '*(1)') self.assertEqual(Q_cm[0][5], '((1)*' + term2_n + '*(1)') self.assertEqual(Q_cm[1][0], 0) self.assertEqual( Q_cm[1][1], '((1)*' + term2_p + '*(1) + ((-1)*' + term3_p + '*(-1) + ((-1)*' + term5_p + '*(-1)') self.assertEqual(Q_cm[1][2], 0) self.assertEqual(Q_cm[1][3], '((1)*' + term2_p + '*(-1)') self.assertEqual( Q_cm[1][4], '((-1)*' + term3_p + '*(1) + ((-1)*' + term5_p + '*(1)') self.assertEqual(Q_cm[1][5], 0) self.assertEqual(Q_cm[2][0], '((-1)*' + term2_n + '*(1)') self.assertEqual(Q_cm[2][1], 0) self.assertEqual( Q_cm[2][2], '((1)*' + term1_n + '*(1) + ((-1)*' + term2_n + '*(-1) + ((-1)*' + term4_n + '*(-1)') self.assertEqual(Q_cm[2][3], 0) self.assertEqual(Q_cm[2][4], 0) self.assertEqual(Q_cm[2][5], '((-1)*' + term2_n + '*(1)') self.assertEqual(Q_cm[3][0], 0) self.assertEqual(Q_cm[3][1], '((-1)*' + term2_p + '*(1)') self.assertEqual(Q_cm[3][2], 0) self.assertEqual( Q_cm[3][3], '((1)*' + term1_p + '*(1) + ((-1)*' + term2_p + '*(-1) + ((-1)*' + term4_p + '*(-1)') self.assertEqual(Q_cm[3][4], 0) self.assertEqual(Q_cm[3][5], 0) self.assertEqual( Q_cm[4][0], '((1)*' + term3_n + '*(-1) + ((1)*' + term5_n + '*(-1)') self.assertEqual( Q_cm[4][1], '((1)*' + term3_p + '*(-1) + ((1)*' + term5_p + '*(-1)') self.assertEqual(Q_cm[4][2], 0) self.assertEqual(Q_cm[4][3], 0) self.assertEqual( Q_cm[4][4], '((1)*' + term3_p + '*(1) + ((1)*' + term3_n + '*(1) + ((1)*' + term5_p + '*(1) + ((1)*' + term5_n + '*(1)') self.assertEqual(Q_cm[4][5], 0) self.assertEqual(Q_cm[5][0], '((1)*' + term2_n + '*(1)') self.assertEqual(Q_cm[5][1], 0) self.assertEqual(Q_cm[5][2], '((1)*' + term2_n + '*(-1)') self.assertEqual(Q_cm[5][3], 0) self.assertEqual(Q_cm[5][4], 0) self.assertEqual(Q_cm[5][5], '((1)*' + term2_n + '*(1)') def test_eval_Q_tricky_cases(self): calc_Q = self.m_noise2.eval_Q() # testing env sto only for m_noise2 : WN on U->S term_p = '(((mu_b_paris*N_paris)*((sto)**2))*(mu_b_paris*N_paris)))' term_n = '(((mu_b_nyc*N_nyc)*((sto)**2))*(mu_b_nyc*N_nyc)))' for i in range(5): for j in range(5): if i == 2 and j == 2: self.assertEqual(calc_Q["no_dem_sto"]["Q_cm"][i][j], '((1)*' + term_n + '*(1)') elif i == 3 and j == 3: self.assertEqual(calc_Q["no_dem_sto"]["Q_cm"][i][j], '((1)*' + term_p + '*(1)') else: self.assertEqual(calc_Q["no_dem_sto"]["Q_cm"][i][j], 0) calc_Q = self.m_noise3.eval_Q() # testing env sto only for m_noise3 : WN on I->R term_p = '((((correct_rate(v))*I_paris)*((sto)**2))*((correct_rate(v))*I_paris)))' term_n = '((((correct_rate(v))*I_nyc)*((sto)**2))*((correct_rate(v))*I_nyc)))' Q_cm = calc_Q["no_dem_sto"]["Q_cm"] for i in range(5): for j in range(5): if i == 0 and j == 0: self.assertEqual(Q_cm[i][j], '((-1)*' + term_n + '*(-1)') elif i == 1 and j == 1: self.assertEqual(Q_cm[i][j], '((-1)*' + term_p + '*(-1)') elif i == 0 and j == 4: self.assertEqual(Q_cm[i][j], '((-1)*' + term_n + '*(1)') elif i == 4 and j == 0: self.assertEqual(Q_cm[i][j], '((1)*' + term_n + '*(-1)') elif i == 1 and j == 4: self.assertEqual(Q_cm[i][j], '((-1)*' + term_p + '*(1)') elif i == 4 and j == 1: self.assertEqual(Q_cm[i][j], '((1)*' + term_p + '*(-1)') elif i == 4 and j == 4: self.assertEqual( Q_cm[i][j], '((1)*' + term_p + '*(1) + ((1)*' + term_n + '*(1)') else: self.assertEqual(Q_cm[i][j], 0) calc_Q = self.m_noise4.eval_Q() # testing env sto only for m_noise4 : WN on I->U term_p = '((((mu_d_paris)*I_paris)*((sto)**2))*((mu_d_paris)*I_paris)))' term_n = '((((mu_d_nyc)*I_nyc)*((sto)**2))*((mu_d_nyc)*I_nyc)))' Q_cm = calc_Q["no_dem_sto"]["Q_cm"] for i in range(5): for j in range(5): if i == 0 and j == 0: self.assertEqual(Q_cm[i][j], '((-1)*' + term_n + '*(-1)') elif i == 1 and j == 1: self.assertEqual(Q_cm[i][j], '((-1)*' + term_p + '*(-1)') elif i == 1 and j == 4: self.assertEqual(Q_cm[i][j], '((-1)*' + term_p + '*(1)') elif i == 4 and j == 1: self.assertEqual(Q_cm[i][j], '((1)*' + term_p + '*(-1)') elif i == 0 and j == 4: self.assertEqual(Q_cm[i][j], '((-1)*' + term_n + '*(1)') elif i == 4 and j == 0: self.assertEqual(Q_cm[i][j], '((1)*' + term_n + '*(-1)') elif i == 4 and j == 4: self.assertEqual( Q_cm[i][j], '((1)*' + term_p + '*(1) + ((1)*' + term_n + '*(1)') else: self.assertEqual(Q_cm[i][j], 0) calc_Q = self.m_noise5.eval_Q() # testing env sto only for m_noise5 : WN on R->U for i in range(5): for j in range(5): self.assertEqual(calc_Q["no_dem_sto"]["Q_cm"][i][j], 0) calc_Q = self.m_noise6.eval_Q() # testing env sto only for m_noise6 : correlated WN on I->R and S->I term1_p = '((r0_paris/N_paris*v*I_paris)*S_paris)' term2_p = '((correct_rate(v))*I_paris)' term1_n = '((r0_nyc/N_nyc*v*I_nyc)*S_nyc)' term2_n = '((correct_rate(v))*I_nyc)' Q_cm = calc_Q["no_dem_sto"]["Q_cm"] self.assertEqual( Q_cm[0][0], '((1)*((' + term1_n + '*((sto)**2))*' + term1_n + ') + (-1)*((' + term2_n + '*((sto)**2))*' + term1_n + '))*(1) + ((1)*((' + term1_n + '*((sto)**2))*' + term2_n + ') + (-1)*((' + term2_n + '*((sto)**2))*' + term2_n + '))*(-1)') self.assertEqual(Q_cm[0][1], 0) self.assertEqual( Q_cm[0][2], '((1)*((' + term1_n + '*((sto)**2))*' + term1_n + ') + (-1)*((' + term2_n + '*((sto)**2))*' + term1_n + '))*(-1)') self.assertEqual(Q_cm[0][3], 0) self.assertEqual( Q_cm[0][4], '((1)*((' + term1_n + '*((sto)**2))*' + term2_n + ') + (-1)*((' + term2_n + '*((sto)**2))*' + term2_n + '))*(1)') self.assertEqual( Q_cm[0][5], '((1)*((' + term1_n + '*((sto)**2))*' + term1_n + ') + (-1)*((' + term2_n + '*((sto)**2))*' + term1_n + '))*(1)') self.assertEqual(Q_cm[1][0], 0) self.assertEqual( Q_cm[1][1], '((1)*((' + term1_p + '*((sto)**2))*' + term1_p + ') + (-1)*((' + term2_p + '*((sto)**2))*' + term1_p + '))*(1) + ((1)*((' + term1_p + '*((sto)**2))*' + term2_p + ') + (-1)*((' + term2_p + '*((sto)**2))*' + term2_p + '))*(-1)') self.assertEqual(Q_cm[1][2], 0) self.assertEqual( Q_cm[1][3], '((1)*((' + term1_p + '*((sto)**2))*' + term1_p + ') + (-1)*((' + term2_p + '*((sto)**2))*' + term1_p + '))*(-1)') self.assertEqual( Q_cm[1][4], '((1)*((' + term1_p + '*((sto)**2))*' + term2_p + ') + (-1)*((' + term2_p + '*((sto)**2))*' + term2_p + '))*(1)') self.assertEqual(Q_cm[1][5], 0) self.assertEqual( Q_cm[2][0], '((-1)*((' + term1_n + '*((sto)**2))*' + term1_n + '))*(1) + ((-1)*((' + term1_n + '*((sto)**2))*' + term2_n + '))*(-1)') self.assertEqual(Q_cm[2][1], 0) self.assertEqual( Q_cm[2][2], '((-1)*((' + term1_n + '*((sto)**2))*' + term1_n + '))*(-1)') self.assertEqual(Q_cm[2][3], 0) self.assertEqual( Q_cm[2][4], '((-1)*((' + term1_n + '*((sto)**2))*' + term2_n + '))*(1)') self.assertEqual( Q_cm[2][5], '((-1)*((' + term1_n + '*((sto)**2))*' + term1_n + '))*(1)') self.assertEqual(Q_cm[3][0], 0) self.assertEqual( Q_cm[3][1], '((-1)*((' + term1_p + '*((sto)**2))*' + term1_p + '))*(1) + ((-1)*((' + term1_p + '*((sto)**2))*' + term2_p + '))*(-1)') self.assertEqual(Q_cm[3][2], 0) self.assertEqual( Q_cm[3][3], '((-1)*((' + term1_p + '*((sto)**2))*' + term1_p + '))*(-1)') self.assertEqual( Q_cm[3][4], '((-1)*((' + term1_p + '*((sto)**2))*' + term2_p + '))*(1)') self.assertEqual(Q_cm[3][5], 0) self.assertEqual( Q_cm[4][0], '((1)*((' + term2_n + '*((sto)**2))*' + term1_n + '))*(1) + ((1)*((' + term2_n + '*((sto)**2))*' + term2_n + '))*(-1)') self.assertEqual( Q_cm[4][1], '((1)*((' + term2_p + '*((sto)**2))*' + term1_p + '))*(1) + ((1)*((' + term2_p + '*((sto)**2))*' + term2_p + '))*(-1)') self.assertEqual( Q_cm[4][2], '((1)*((' + term2_n + '*((sto)**2))*' + term1_n + '))*(-1)') self.assertEqual( Q_cm[4][3], '((1)*((' + term2_p + '*((sto)**2))*' + term1_p + '))*(-1)') self.assertEqual( Q_cm[4][4], '((1)*((' + term2_p + '*((sto)**2))*' + term2_p + '))*(1) + ((1)*((' + term2_n + '*((sto)**2))*' + term2_n + '))*(1)') self.assertEqual( Q_cm[4][5], '((1)*((' + term2_n + '*((sto)**2))*' + term1_n + '))*(1)') self.assertEqual( Q_cm[5][0], '((1)*((' + term1_n + '*((sto)**2))*' + term1_n + '))*(1) + ((1)*((' + term1_n + '*((sto)**2))*' + term2_n + '))*(-1)') self.assertEqual(Q_cm[5][1], 0) self.assertEqual( Q_cm[5][2], '((1)*((' + term1_n + '*((sto)**2))*' + term1_n + '))*(-1)') self.assertEqual(Q_cm[5][3], 0) self.assertEqual( Q_cm[5][4], '((1)*((' + term1_n + '*((sto)**2))*' + term2_n + '))*(1)') self.assertEqual( Q_cm[5][5], '((1)*((' + term1_n + '*((sto)**2))*' + term1_n + '))*(1)') calc_Q = self.m_noise7.eval_Q() # testing env sto only for m_noise7 : uncorrelated WN on I->R and S->I term1_p = '((r0_paris/N_paris*v*I_paris)*S_paris)' term2_p = '((correct_rate(v))*I_paris)' term1_n = '((r0_nyc/N_nyc*v*I_nyc)*S_nyc)' term2_n = '((correct_rate(v))*I_nyc)' Q_cm = calc_Q["no_dem_sto"]["Q_cm"] self.assertEqual( Q_cm[0][0], '((1)*((' + term1_n + '*((sto)**2))*' + term1_n + '))*(1) + ((-1)*((' + term2_n + '*((sto)**2))*' + term2_n + '))*(-1)') self.assertEqual(Q_cm[0][1], 0) self.assertEqual( Q_cm[0][2], '((1)*((' + term1_n + '*((sto)**2))*' + term1_n + '))*(-1)') self.assertEqual(Q_cm[0][3], 0) self.assertEqual( Q_cm[0][4], '((-1)*((' + term2_n + '*((sto)**2))*' + term2_n + '))*(1)') self.assertEqual( Q_cm[0][5], '((1)*((' + term1_n + '*((sto)**2))*' + term1_n + '))*(1)') self.assertEqual(Q_cm[1][0], 0) self.assertEqual( Q_cm[1][1], '((1)*((' + term1_p + '*((sto)**2))*' + term1_p + '))*(1) + ((-1)*((' + term2_p + '*((sto)**2))*' + term2_p + '))*(-1)') self.assertEqual(Q_cm[1][2], 0) self.assertEqual( Q_cm[1][3], '((1)*((' + term1_p + '*((sto)**2))*' + term1_p + '))*(-1)') self.assertEqual( Q_cm[1][4], '((-1)*((' + term2_p + '*((sto)**2))*' + term2_p + '))*(1)') self.assertEqual(Q_cm[1][5], 0) self.assertEqual( Q_cm[2][0], '((-1)*((' + term1_n + '*((sto)**2))*' + term1_n + '))*(1)') self.assertEqual(Q_cm[2][1], 0) self.assertEqual( Q_cm[2][2], '((-1)*((' + term1_n + '*((sto)**2))*' + term1_n + '))*(-1)') self.assertEqual(Q_cm[2][3], 0) self.assertEqual(Q_cm[2][4], 0) self.assertEqual( Q_cm[2][5], '((-1)*((' + term1_n + '*((sto)**2))*' + term1_n + '))*(1)') self.assertEqual(Q_cm[3][0], 0) self.assertEqual( Q_cm[3][1], '((-1)*((' + term1_p + '*((sto)**2))*' + term1_p + '))*(1)') self.assertEqual(Q_cm[3][2], 0) self.assertEqual( Q_cm[3][3], '((-1)*((' + term1_p + '*((sto)**2))*' + term1_p + '))*(-1)') self.assertEqual(Q_cm[3][4], 0) self.assertEqual(Q_cm[3][5], 0) self.assertEqual( Q_cm[4][0], '((1)*((' + term2_n + '*((sto)**2))*' + term2_n + '))*(-1)') self.assertEqual( Q_cm[4][1], '((1)*((' + term2_p + '*((sto)**2))*' + term2_p + '))*(-1)') self.assertEqual(Q_cm[4][2], 0) self.assertEqual(Q_cm[4][3], 0) self.assertEqual( Q_cm[4][4], '((1)*((' + term2_p + '*((sto)**2))*' + term2_p + '))*(1) + ((1)*((' + term2_n + '*((sto)**2))*' + term2_n + '))*(1)') self.assertEqual(Q_cm[4][5], 0) self.assertEqual( Q_cm[5][0], '((1)*((' + term1_n + '*((sto)**2))*' + term1_n + '))*(1)') self.assertEqual(Q_cm[5][1], 0) self.assertEqual( Q_cm[5][2], '((1)*((' + term1_n + '*((sto)**2))*' + term1_n + '))*(-1)') self.assertEqual(Q_cm[5][3], 0) self.assertEqual(Q_cm[5][4], 0) self.assertEqual( Q_cm[5][5], '((1)*((' + term1_n + '*((sto)**2))*' + term1_n + '))*(1)') def test_jac(self): step_ode_sde = self.m_noise.step_ode_sde() jac = self.m_diff.jac(step_ode_sde['sf']) # testing jac # I ode - ((v)*I) - ((mu_d)*I) + ((r0/N*v*I)*S) self.assertEqual( jac['caches'][jac['jac'][0][0]], '-gsl_spline_eval(calc->spline[ORDER_mu_d_nyc],t,calc->acc[ORDER_mu_d_nyc])-(gsl_vector_get(par,ORDER_v))+X[ORDER_S_nyc]*diffed[ORDER_diff__r0_nyc]*gsl_vector_get(par,ORDER_v)/gsl_spline_eval(calc->spline[ORDER_N_nyc],t,calc->acc[ORDER_N_nyc])' ) self.assertEqual( jac['caches'][jac['jac'][1][1]], '-gsl_spline_eval(calc->spline[ORDER_mu_d_paris],t,calc->acc[ORDER_mu_d_paris])-(gsl_vector_get(par,ORDER_v))+X[ORDER_S_paris]*diffed[ORDER_diff__r0_paris]*gsl_vector_get(par,ORDER_v)/gsl_spline_eval(calc->spline[ORDER_N_paris],t,calc->acc[ORDER_N_paris])' ) self.assertEqual(jac['caches'][jac['jac_diff'][1][0]['value']], '0') self.assertEqual(jac['caches'][jac['jac_diff'][0][1]['value']], '0') # S ode - ((r0/N*v*I)*S) - ((mu_d)*S) + (mu_b*N) self.assertEqual( jac['caches'][jac['jac'][2][2]], '-X[ORDER_I_nyc]*diffed[ORDER_diff__r0_nyc]*gsl_vector_get(par,ORDER_v)/gsl_spline_eval(calc->spline[ORDER_N_nyc],t,calc->acc[ORDER_N_nyc])-gsl_spline_eval(calc->spline[ORDER_mu_d_nyc],t,calc->acc[ORDER_mu_d_nyc])' ) self.assertEqual( jac['caches'][jac['jac'][3][3]], '-X[ORDER_I_paris]*diffed[ORDER_diff__r0_paris]*gsl_vector_get(par,ORDER_v)/gsl_spline_eval(calc->spline[ORDER_N_paris],t,calc->acc[ORDER_N_paris])-gsl_spline_eval(calc->spline[ORDER_mu_d_paris],t,calc->acc[ORDER_mu_d_paris])' ) self.assertEqual( jac['caches'][jac['jac'][2][0]], '-X[ORDER_S_nyc]*diffed[ORDER_diff__r0_nyc]*gsl_vector_get(par,ORDER_v)/gsl_spline_eval(calc->spline[ORDER_N_nyc],t,calc->acc[ORDER_N_nyc])' ) self.assertEqual( jac['caches'][jac['jac'][3][1]], '-X[ORDER_S_paris]*diffed[ORDER_diff__r0_paris]*gsl_vector_get(par,ORDER_v)/gsl_spline_eval(calc->spline[ORDER_N_paris],t,calc->acc[ORDER_N_paris])' ) # testing jac_obs # all_inc self.assertEqual( jac['caches'][jac['jac_obs'][0][0]], 'gsl_spline_eval(calc->spline[ORDER_mu_d_nyc],t,calc->acc[ORDER_mu_d_nyc])+(gsl_vector_get(par,ORDER_v))' ) self.assertEqual( jac['caches'][jac['jac_obs'][0][1]], 'gsl_spline_eval(calc->spline[ORDER_mu_d_paris],t,calc->acc[ORDER_mu_d_paris])+(gsl_vector_get(par,ORDER_v))' ) self.assertEqual(jac['caches'][jac['jac_obs_diff'][0][0]['value']], '0') self.assertEqual(jac['caches'][jac['jac_obs_diff'][0][1]['value']], '0') # nyc_inc self.assertEqual( jac['caches'][jac['jac_obs'][1][0]], 'X[ORDER_S_nyc]*diffed[ORDER_diff__r0_nyc]*gsl_vector_get(par,ORDER_v)/gsl_spline_eval(calc->spline[ORDER_N_nyc],t,calc->acc[ORDER_N_nyc])' ) self.assertEqual(jac['caches'][jac['jac_obs'][1][1]], '0') self.assertEqual( jac['caches'][jac['jac_obs_diff'][1][0]['value']], 'X[ORDER_I_nyc]*X[ORDER_S_nyc]*gsl_vector_get(par,ORDER_v)/gsl_spline_eval(calc->spline[ORDER_N_nyc],t,calc->acc[ORDER_N_nyc])' ) self.assertEqual(jac['caches'][jac['jac_obs_diff'][1][1]['value']], '0') def test_cache_special_function_C(self): caches = map(lambda x: self.m_diff.make_C_term(x, False), [ 'sin(2*PI*(t +r0))', 'sin(2*PI*(t +r0))', 'sin(2*PI*(t +r0)) + correct_rate(v)' ]) sf = self.m_diff.cache_special_function_C(caches) self.assertEqual(sf, [ 'sin(2*PI*(r0+t))', 'ssm_correct_rate(gsl_vector_get(par,ORDER_v),dt)' ]) self.assertEqual(caches, ['_sf[0]', '_sf[0]', '_sf[1]+_sf[0]']) def test_cache_special_function_C_nested(self): caches = map(lambda x: self.m_diff.make_C_term(x, False), ['pow(correct_rate(correct_rate(v)), pow(2,4))']) sf = self.m_diff.cache_special_function_C(caches) self.assertEqual(sf, [ 'pow(ssm_correct_rate(ssm_correct_rate(gsl_vector_get(par,ORDER_v),dt),dt),pow(2,4))' ]) self.assertEqual(caches, ['_sf[0]'])
def setUp(self): dpkgRoot = os.path.join('..' ,'examples', 'noise') dpkg = json.load(open(os.path.join(dpkgRoot, 'ssm.json'))) self.m_noise = Ccoder(dpkgRoot, copy.deepcopy(dpkg)) m_diff = copy.deepcopy(dpkg) del m_diff['reactions'][2]['white_noise'] del m_diff['reactions'][3]['white_noise'] m_diff['sde'] = { 'drift': [ {'name': 'r0_paris', 'f': 0.0, 'transformation': 'log(r0_paris)'}, {'name': 'r0_nyc', 'f': 0.0, 'transformation': 'log(r0_nyc)'} ], 'dispertion': [['vol',0],[0,'vol']] } self.m_diff = Ccoder(dpkgRoot, m_diff) m_noise2 = copy.deepcopy(dpkg) del m_noise2['reactions'][2]['white_noise'] del m_noise2['reactions'][3]['white_noise'] m_noise2['reactions'][0]['white_noise'] = {'name':'noise_SI', 'sd': 'sto'} m_noise2['reactions'][1]['white_noise'] = {'name':'noise_SI2', 'sd': 'sto'} self.m_noise2 = Ccoder(dpkgRoot, m_noise2) m_noise3 = copy.deepcopy(dpkg) del m_noise3['reactions'][2]['white_noise'] del m_noise3['reactions'][3]['white_noise'] m_noise3['reactions'][4]['white_noise'] = {'name':'noise_SI', 'sd': 'sto'} m_noise3['reactions'][5]['white_noise'] = {'name':'noise_SI2', 'sd': 'sto'} self.m_noise3 = Ccoder(dpkgRoot, m_noise3) m_noise4 = copy.deepcopy(dpkg) del m_noise4['reactions'][2]['white_noise'] del m_noise4['reactions'][3]['white_noise'] m_noise4['reactions'][8]['white_noise'] = {'name':'noise_SI', 'sd': 'sto'} m_noise4['reactions'][9]['white_noise'] = {'name':'noise_SI2', 'sd': 'sto'} self.m_noise4 = Ccoder(dpkgRoot, m_noise4) m_noise5 = copy.deepcopy(dpkg) del m_noise5['reactions'][2]['white_noise'] del m_noise5['reactions'][3]['white_noise'] m_noise5['reactions'][10]['white_noise'] = {'name':'noise_SI', 'sd': 'sto'} m_noise5['reactions'][11]['white_noise'] = {'name':'noise_SI2', 'sd': 'sto'} self.m_noise5 = Ccoder(dpkgRoot, m_noise5) m_noise6 = copy.deepcopy(dpkg) m_noise6['reactions'][4]['white_noise'] = {'name':'noise_SI', 'sd': 'sto'} m_noise6['reactions'][5]['white_noise'] = {'name':'noise_SI2', 'sd': 'sto'} self.m_noise6 = Ccoder(dpkgRoot, m_noise6) m_noise7 = copy.deepcopy(dpkg) m_noise7['reactions'][4]['white_noise'] = {'name':'noise_SI23', 'sd': 'sto'} m_noise7['reactions'][5]['white_noise'] = {'name':'noise_SI24', 'sd': 'sto'} self.m_noise7 = Ccoder(dpkgRoot, m_noise7) m_diff2 = copy.deepcopy(dpkg) del m_diff2['reactions'][2]['white_noise'] del m_diff2['reactions'][3]['white_noise'] m_diff2['sde'] = copy.deepcopy(m_diff['sde']) m_diff2['reactions'].append({'from': 'R_paris', 'to': 'I_paris', 'rate': 'correct_rate(v)', 'description':'testing'}) m_diff2['reactions'].append({'from': 'R_nyc', 'to': 'I_nyc', 'rate': 'correct_rate(v)', 'description':'testing'}) self.m_diff2 = Ccoder(dpkgRoot, m_diff2)
class TestCcoder(unittest.TestCase): def setUp(self): dpkgRoot = os.path.join('..' ,'examples', 'noise') dpkg = json.load(open(os.path.join(dpkgRoot, 'ssm.json'))) self.m_noise = Ccoder(dpkgRoot, copy.deepcopy(dpkg)) m_diff = copy.deepcopy(dpkg) del m_diff['reactions'][2]['white_noise'] del m_diff['reactions'][3]['white_noise'] m_diff['sde'] = { 'drift': [ {'name': 'r0_paris', 'f': 0.0, 'transformation': 'log(r0_paris)'}, {'name': 'r0_nyc', 'f': 0.0, 'transformation': 'log(r0_nyc)'} ], 'dispertion': [['vol',0],[0,'vol']] } self.m_diff = Ccoder(dpkgRoot, m_diff) m_noise2 = copy.deepcopy(dpkg) del m_noise2['reactions'][2]['white_noise'] del m_noise2['reactions'][3]['white_noise'] m_noise2['reactions'][0]['white_noise'] = {'name':'noise_SI', 'sd': 'sto'} m_noise2['reactions'][1]['white_noise'] = {'name':'noise_SI2', 'sd': 'sto'} self.m_noise2 = Ccoder(dpkgRoot, m_noise2) m_noise3 = copy.deepcopy(dpkg) del m_noise3['reactions'][2]['white_noise'] del m_noise3['reactions'][3]['white_noise'] m_noise3['reactions'][4]['white_noise'] = {'name':'noise_SI', 'sd': 'sto'} m_noise3['reactions'][5]['white_noise'] = {'name':'noise_SI2', 'sd': 'sto'} self.m_noise3 = Ccoder(dpkgRoot, m_noise3) m_noise4 = copy.deepcopy(dpkg) del m_noise4['reactions'][2]['white_noise'] del m_noise4['reactions'][3]['white_noise'] m_noise4['reactions'][8]['white_noise'] = {'name':'noise_SI', 'sd': 'sto'} m_noise4['reactions'][9]['white_noise'] = {'name':'noise_SI2', 'sd': 'sto'} self.m_noise4 = Ccoder(dpkgRoot, m_noise4) m_noise5 = copy.deepcopy(dpkg) del m_noise5['reactions'][2]['white_noise'] del m_noise5['reactions'][3]['white_noise'] m_noise5['reactions'][10]['white_noise'] = {'name':'noise_SI', 'sd': 'sto'} m_noise5['reactions'][11]['white_noise'] = {'name':'noise_SI2', 'sd': 'sto'} self.m_noise5 = Ccoder(dpkgRoot, m_noise5) m_noise6 = copy.deepcopy(dpkg) m_noise6['reactions'][4]['white_noise'] = {'name':'noise_SI', 'sd': 'sto'} m_noise6['reactions'][5]['white_noise'] = {'name':'noise_SI2', 'sd': 'sto'} self.m_noise6 = Ccoder(dpkgRoot, m_noise6) m_noise7 = copy.deepcopy(dpkg) m_noise7['reactions'][4]['white_noise'] = {'name':'noise_SI23', 'sd': 'sto'} m_noise7['reactions'][5]['white_noise'] = {'name':'noise_SI24', 'sd': 'sto'} self.m_noise7 = Ccoder(dpkgRoot, m_noise7) m_diff2 = copy.deepcopy(dpkg) del m_diff2['reactions'][2]['white_noise'] del m_diff2['reactions'][3]['white_noise'] m_diff2['sde'] = copy.deepcopy(m_diff['sde']) m_diff2['reactions'].append({'from': 'R_paris', 'to': 'I_paris', 'rate': 'correct_rate(v)', 'description':'testing'}) m_diff2['reactions'].append({'from': 'R_nyc', 'to': 'I_nyc', 'rate': 'correct_rate(v)', 'description':'testing'}) self.m_diff2 = Ccoder(dpkgRoot, m_diff2) def test_eval_Q(self): calc_Q = self.m_noise.eval_Q() # testing env sto only # order: I_nyc, I_paris, S_nyc, S_paris, inc_all , inc_nyc term_paris = '((((r0_paris/N_paris*v*I_paris)*S_paris)*((sto)**2))*((r0_paris/N_paris*v*I_paris)*S_paris)))' term_nyc = '((((r0_nyc/N_nyc*v*I_nyc)*S_nyc)*((sto)**2))*((r0_nyc/N_nyc*v*I_nyc)*S_nyc)))' Q_cm = calc_Q["no_dem_sto"]["Q_cm"] self.assertEqual(Q_cm[0][0], '((1)*'+term_nyc+'*(1)') self.assertEqual(Q_cm[0][1], 0) self.assertEqual(Q_cm[0][2], '((1)*'+term_nyc+'*(-1)') self.assertEqual(Q_cm[0][3], 0) self.assertEqual(Q_cm[0][4], 0) self.assertEqual(Q_cm[0][5], '((1)*'+term_nyc+'*(1)') self.assertEqual(Q_cm[1][0], 0) self.assertEqual(Q_cm[1][1], '((1)*'+term_paris+'*(1)') self.assertEqual(Q_cm[1][2], 0) self.assertEqual(Q_cm[1][3], '((1)*'+term_paris+'*(-1)') self.assertEqual(Q_cm[1][4], 0) self.assertEqual(Q_cm[1][5], 0) self.assertEqual(Q_cm[2][0], '((-1)*'+term_nyc+'*(1)') self.assertEqual(Q_cm[2][1], 0) self.assertEqual(Q_cm[2][2], '((-1)*'+term_nyc+'*(-1)') self.assertEqual(Q_cm[2][3], 0) self.assertEqual(Q_cm[2][4], 0) self.assertEqual(Q_cm[2][5], '((-1)*'+term_nyc+'*(1)') self.assertEqual(Q_cm[3][0], 0) self.assertEqual(Q_cm[3][1], '((-1)*'+term_paris+'*(1)') self.assertEqual(Q_cm[3][2], 0) self.assertEqual(Q_cm[3][3], '((-1)*'+term_paris+'*(-1)') self.assertEqual(Q_cm[3][4], 0) self.assertEqual(Q_cm[3][5], 0) self.assertEqual(Q_cm[4][0], 0) self.assertEqual(Q_cm[4][1], 0) self.assertEqual(Q_cm[4][2], 0) self.assertEqual(Q_cm[4][3], 0) self.assertEqual(Q_cm[4][4], 0) self.assertEqual(Q_cm[4][5], 0) self.assertEqual(Q_cm[5][0], '((1)*'+term_nyc+'*(1)') self.assertEqual(Q_cm[5][1], 0) self.assertEqual(Q_cm[5][2], '((1)*'+term_nyc+'*(-1)') self.assertEqual(Q_cm[5][3], 0) self.assertEqual(Q_cm[5][4], 0) self.assertEqual(Q_cm[5][5], '((1)*'+term_nyc+'*(1)') # testing dem sto only term1_p = '(mu_b_paris*N_paris))' term2_p = '((r0_paris/N_paris*v*I_paris)*S_paris))' term3_p = '((correct_rate(v))*I_paris))' term4_p = '((mu_d_paris)*S_paris))' term5_p = '((mu_d_paris)*I_paris))' term1_n = '(mu_b_nyc*N_nyc))' term2_n = '((r0_nyc/N_nyc*v*I_nyc)*S_nyc))' term3_n = '((correct_rate(v))*I_nyc))' term4_n = '((mu_d_nyc)*S_nyc))' term5_n = '((mu_d_nyc)*I_nyc))' # order: I_nyc, I_paris, S_nyc, S_paris, inc_all , inc_nyc Q_cm = calc_Q["no_env_sto"]["Q_cm"] self.assertEqual(Q_cm[0][0], '((1)*'+term2_n+'*(1) + ((-1)*'+term3_n+'*(-1) + ((-1)*'+term5_n+'*(-1)') self.assertEqual(Q_cm[0][1], 0) self.assertEqual(Q_cm[0][2], '((1)*'+term2_n+'*(-1)') self.assertEqual(Q_cm[0][3], 0) self.assertEqual(Q_cm[0][4], '((-1)*'+term3_n+'*(1) + ((-1)*'+term5_n+'*(1)') self.assertEqual(Q_cm[0][5], '((1)*'+term2_n+'*(1)') self.assertEqual(Q_cm[1][0], 0) self.assertEqual(Q_cm[1][1], '((1)*'+term2_p+'*(1) + ((-1)*'+term3_p+'*(-1) + ((-1)*'+term5_p+'*(-1)') self.assertEqual(Q_cm[1][2], 0) self.assertEqual(Q_cm[1][3], '((1)*'+term2_p+'*(-1)') self.assertEqual(Q_cm[1][4], '((-1)*'+term3_p+'*(1) + ((-1)*'+term5_p+'*(1)') self.assertEqual(Q_cm[1][5], 0) self.assertEqual(Q_cm[2][0], '((-1)*'+term2_n+'*(1)') self.assertEqual(Q_cm[2][1], 0) self.assertEqual(Q_cm[2][2], '((1)*'+term1_n+'*(1) + ((-1)*'+term2_n+'*(-1) + ((-1)*'+term4_n+'*(-1)') self.assertEqual(Q_cm[2][3], 0) self.assertEqual(Q_cm[2][4], 0) self.assertEqual(Q_cm[2][5], '((-1)*'+term2_n+'*(1)') self.assertEqual(Q_cm[3][0], 0) self.assertEqual(Q_cm[3][1], '((-1)*'+term2_p+'*(1)') self.assertEqual(Q_cm[3][2], 0) self.assertEqual(Q_cm[3][3], '((1)*'+term1_p+'*(1) + ((-1)*'+term2_p+'*(-1) + ((-1)*'+term4_p+'*(-1)') self.assertEqual(Q_cm[3][4], 0) self.assertEqual(Q_cm[3][5], 0) self.assertEqual(Q_cm[4][0], '((1)*'+term3_n+'*(-1) + ((1)*'+term5_n+'*(-1)') self.assertEqual(Q_cm[4][1], '((1)*'+term3_p+'*(-1) + ((1)*'+term5_p+'*(-1)') self.assertEqual(Q_cm[4][2], 0) self.assertEqual(Q_cm[4][3], 0) self.assertEqual(Q_cm[4][4], '((1)*'+term3_p+'*(1) + ((1)*'+term3_n+'*(1) + ((1)*'+term5_p+'*(1) + ((1)*'+term5_n+'*(1)') self.assertEqual(Q_cm[4][5], 0) self.assertEqual(Q_cm[5][0], '((1)*'+term2_n+'*(1)') self.assertEqual(Q_cm[5][1], 0) self.assertEqual(Q_cm[5][2], '((1)*'+term2_n+'*(-1)') self.assertEqual(Q_cm[5][3], 0) self.assertEqual(Q_cm[5][4], 0) self.assertEqual(Q_cm[5][5], '((1)*'+term2_n+'*(1)') def test_eval_Q_tricky_cases(self): calc_Q = self.m_noise2.eval_Q() # testing env sto only for m_noise2 : WN on U->S term_p = '(((mu_b_paris*N_paris)*((sto)**2))*(mu_b_paris*N_paris)))' term_n = '(((mu_b_nyc*N_nyc)*((sto)**2))*(mu_b_nyc*N_nyc)))' for i in range(5): for j in range(5): if i==2 and j == 2: self.assertEqual(calc_Q["no_dem_sto"]["Q_cm"][i][j],'((1)*'+term_n+'*(1)') elif i==3 and j == 3: self.assertEqual(calc_Q["no_dem_sto"]["Q_cm"][i][j],'((1)*'+term_p+'*(1)') else: self.assertEqual(calc_Q["no_dem_sto"]["Q_cm"][i][j],0) calc_Q = self.m_noise3.eval_Q() # testing env sto only for m_noise3 : WN on I->R term_p = '((((correct_rate(v))*I_paris)*((sto)**2))*((correct_rate(v))*I_paris)))' term_n = '((((correct_rate(v))*I_nyc)*((sto)**2))*((correct_rate(v))*I_nyc)))' Q_cm = calc_Q["no_dem_sto"]["Q_cm"] for i in range(5): for j in range(5): if i==0 and j == 0: self.assertEqual(Q_cm[i][j], '((-1)*'+term_n+'*(-1)') elif i==1 and j == 1: self.assertEqual(Q_cm[i][j], '((-1)*'+term_p+'*(-1)') elif i==0 and j == 4: self.assertEqual(Q_cm[i][j], '((-1)*'+term_n+'*(1)') elif i==4 and j == 0: self.assertEqual(Q_cm[i][j], '((1)*'+term_n+'*(-1)') elif i==1 and j == 4: self.assertEqual(Q_cm[i][j], '((-1)*'+term_p+'*(1)') elif i==4 and j == 1: self.assertEqual(Q_cm[i][j], '((1)*'+term_p+'*(-1)') elif i==4 and j == 4: self.assertEqual(Q_cm[i][j], '((1)*'+term_p+'*(1) + ((1)*'+term_n+'*(1)') else: self.assertEqual(Q_cm[i][j], 0) calc_Q = self.m_noise4.eval_Q() # testing env sto only for m_noise4 : WN on I->U term_p = '((((mu_d_paris)*I_paris)*((sto)**2))*((mu_d_paris)*I_paris)))' term_n = '((((mu_d_nyc)*I_nyc)*((sto)**2))*((mu_d_nyc)*I_nyc)))' Q_cm = calc_Q["no_dem_sto"]["Q_cm"] for i in range(5): for j in range(5): if i==0 and j == 0: self.assertEqual(Q_cm[i][j], '((-1)*'+term_n+'*(-1)') elif i==1 and j == 1: self.assertEqual(Q_cm[i][j], '((-1)*'+term_p+'*(-1)') elif i==1 and j == 4: self.assertEqual(Q_cm[i][j], '((-1)*'+term_p+'*(1)') elif i==4 and j == 1: self.assertEqual(Q_cm[i][j], '((1)*'+term_p+'*(-1)') elif i==0 and j == 4: self.assertEqual(Q_cm[i][j], '((-1)*'+term_n+'*(1)') elif i==4 and j == 0: self.assertEqual(Q_cm[i][j], '((1)*'+term_n+'*(-1)') elif i==4 and j == 4: self.assertEqual(Q_cm[i][j], '((1)*'+term_p+'*(1) + ((1)*'+term_n+'*(1)') else: self.assertEqual(Q_cm[i][j], 0) calc_Q = self.m_noise5.eval_Q() # testing env sto only for m_noise5 : WN on R->U for i in range(5): for j in range(5): self.assertEqual(calc_Q["no_dem_sto"]["Q_cm"][i][j],0) calc_Q = self.m_noise6.eval_Q() # testing env sto only for m_noise6 : correlated WN on I->R and S->I term1_p = '((r0_paris/N_paris*v*I_paris)*S_paris)' term2_p = '((correct_rate(v))*I_paris)' term1_n = '((r0_nyc/N_nyc*v*I_nyc)*S_nyc)' term2_n = '((correct_rate(v))*I_nyc)' Q_cm = calc_Q["no_dem_sto"]["Q_cm"] self.assertEqual(Q_cm[0][0], '((1)*(('+term1_n+'*((sto)**2))*'+term1_n+') + (-1)*(('+term2_n+'*((sto)**2))*'+term1_n+'))*(1) + ((1)*(('+term1_n+'*((sto)**2))*'+term2_n+') + (-1)*(('+term2_n+'*((sto)**2))*'+term2_n+'))*(-1)') self.assertEqual(Q_cm[0][1], 0) self.assertEqual(Q_cm[0][2], '((1)*(('+term1_n+'*((sto)**2))*'+term1_n+') + (-1)*(('+term2_n+'*((sto)**2))*'+term1_n+'))*(-1)') self.assertEqual(Q_cm[0][3], 0) self.assertEqual(Q_cm[0][4], '((1)*(('+term1_n+'*((sto)**2))*'+term2_n+') + (-1)*(('+term2_n+'*((sto)**2))*'+term2_n+'))*(1)') self.assertEqual(Q_cm[0][5], '((1)*(('+term1_n+'*((sto)**2))*'+term1_n+') + (-1)*(('+term2_n+'*((sto)**2))*'+term1_n+'))*(1)') self.assertEqual(Q_cm[1][0], 0) self.assertEqual(Q_cm[1][1], '((1)*(('+term1_p+'*((sto)**2))*'+term1_p+') + (-1)*(('+term2_p+'*((sto)**2))*'+term1_p+'))*(1) + ((1)*(('+term1_p+'*((sto)**2))*'+term2_p+') + (-1)*(('+term2_p+'*((sto)**2))*'+term2_p+'))*(-1)') self.assertEqual(Q_cm[1][2], 0) self.assertEqual(Q_cm[1][3], '((1)*(('+term1_p+'*((sto)**2))*'+term1_p+') + (-1)*(('+term2_p+'*((sto)**2))*'+term1_p+'))*(-1)') self.assertEqual(Q_cm[1][4], '((1)*(('+term1_p+'*((sto)**2))*'+term2_p+') + (-1)*(('+term2_p+'*((sto)**2))*'+term2_p+'))*(1)') self.assertEqual(Q_cm[1][5], 0) self.assertEqual(Q_cm[2][0], '((-1)*(('+term1_n+'*((sto)**2))*'+term1_n+'))*(1) + ((-1)*(('+term1_n+'*((sto)**2))*'+term2_n+'))*(-1)') self.assertEqual(Q_cm[2][1], 0) self.assertEqual(Q_cm[2][2], '((-1)*(('+term1_n+'*((sto)**2))*'+term1_n+'))*(-1)') self.assertEqual(Q_cm[2][3], 0) self.assertEqual(Q_cm[2][4], '((-1)*(('+term1_n+'*((sto)**2))*'+term2_n+'))*(1)') self.assertEqual(Q_cm[2][5], '((-1)*(('+term1_n+'*((sto)**2))*'+term1_n+'))*(1)') self.assertEqual(Q_cm[3][0], 0) self.assertEqual(Q_cm[3][1], '((-1)*(('+term1_p+'*((sto)**2))*'+term1_p+'))*(1) + ((-1)*(('+term1_p+'*((sto)**2))*'+term2_p+'))*(-1)') self.assertEqual(Q_cm[3][2], 0) self.assertEqual(Q_cm[3][3], '((-1)*(('+term1_p+'*((sto)**2))*'+term1_p+'))*(-1)') self.assertEqual(Q_cm[3][4], '((-1)*(('+term1_p+'*((sto)**2))*'+term2_p+'))*(1)') self.assertEqual(Q_cm[3][5], 0) self.assertEqual(Q_cm[4][0], '((1)*(('+term2_n+'*((sto)**2))*'+term1_n+'))*(1) + ((1)*(('+term2_n+'*((sto)**2))*'+term2_n+'))*(-1)') self.assertEqual(Q_cm[4][1], '((1)*(('+term2_p+'*((sto)**2))*'+term1_p+'))*(1) + ((1)*(('+term2_p+'*((sto)**2))*'+term2_p+'))*(-1)') self.assertEqual(Q_cm[4][2], '((1)*(('+term2_n+'*((sto)**2))*'+term1_n+'))*(-1)') self.assertEqual(Q_cm[4][3], '((1)*(('+term2_p+'*((sto)**2))*'+term1_p+'))*(-1)') self.assertEqual(Q_cm[4][4], '((1)*(('+term2_p+'*((sto)**2))*'+term2_p+'))*(1) + ((1)*(('+term2_n+'*((sto)**2))*'+term2_n+'))*(1)') self.assertEqual(Q_cm[4][5], '((1)*(('+term2_n+'*((sto)**2))*'+term1_n+'))*(1)') self.assertEqual(Q_cm[5][0], '((1)*(('+term1_n+'*((sto)**2))*'+term1_n+'))*(1) + ((1)*(('+term1_n+'*((sto)**2))*'+term2_n+'))*(-1)') self.assertEqual(Q_cm[5][1], 0) self.assertEqual(Q_cm[5][2], '((1)*(('+term1_n+'*((sto)**2))*'+term1_n+'))*(-1)') self.assertEqual(Q_cm[5][3], 0) self.assertEqual(Q_cm[5][4], '((1)*(('+term1_n+'*((sto)**2))*'+term2_n+'))*(1)') self.assertEqual(Q_cm[5][5], '((1)*(('+term1_n+'*((sto)**2))*'+term1_n+'))*(1)') calc_Q = self.m_noise7.eval_Q() # testing env sto only for m_noise7 : uncorrelated WN on I->R and S->I term1_p = '((r0_paris/N_paris*v*I_paris)*S_paris)' term2_p = '((correct_rate(v))*I_paris)' term1_n = '((r0_nyc/N_nyc*v*I_nyc)*S_nyc)' term2_n = '((correct_rate(v))*I_nyc)' Q_cm = calc_Q["no_dem_sto"]["Q_cm"] self.assertEqual(Q_cm[0][0], '((1)*(('+term1_n+'*((sto)**2))*'+term1_n+'))*(1) + ((-1)*(('+term2_n+'*((sto)**2))*'+term2_n+'))*(-1)') self.assertEqual(Q_cm[0][1], 0) self.assertEqual(Q_cm[0][2], '((1)*(('+term1_n+'*((sto)**2))*'+term1_n+'))*(-1)') self.assertEqual(Q_cm[0][3], 0) self.assertEqual(Q_cm[0][4], '((-1)*(('+term2_n+'*((sto)**2))*'+term2_n+'))*(1)') self.assertEqual(Q_cm[0][5], '((1)*(('+term1_n+'*((sto)**2))*'+term1_n+'))*(1)') self.assertEqual(Q_cm[1][0], 0) self.assertEqual(Q_cm[1][1], '((1)*(('+term1_p+'*((sto)**2))*'+term1_p+'))*(1) + ((-1)*(('+term2_p+'*((sto)**2))*'+term2_p+'))*(-1)') self.assertEqual(Q_cm[1][2], 0) self.assertEqual(Q_cm[1][3], '((1)*(('+term1_p+'*((sto)**2))*'+term1_p+'))*(-1)') self.assertEqual(Q_cm[1][4], '((-1)*(('+term2_p+'*((sto)**2))*'+term2_p+'))*(1)') self.assertEqual(Q_cm[1][5], 0) self.assertEqual(Q_cm[2][0], '((-1)*(('+term1_n+'*((sto)**2))*'+term1_n+'))*(1)') self.assertEqual(Q_cm[2][1], 0) self.assertEqual(Q_cm[2][2], '((-1)*(('+term1_n+'*((sto)**2))*'+term1_n+'))*(-1)') self.assertEqual(Q_cm[2][3], 0) self.assertEqual(Q_cm[2][4], 0) self.assertEqual(Q_cm[2][5], '((-1)*(('+term1_n+'*((sto)**2))*'+term1_n+'))*(1)') self.assertEqual(Q_cm[3][0], 0) self.assertEqual(Q_cm[3][1], '((-1)*(('+term1_p+'*((sto)**2))*'+term1_p+'))*(1)') self.assertEqual(Q_cm[3][2], 0) self.assertEqual(Q_cm[3][3], '((-1)*(('+term1_p+'*((sto)**2))*'+term1_p+'))*(-1)') self.assertEqual(Q_cm[3][4], 0) self.assertEqual(Q_cm[3][5], 0) self.assertEqual(Q_cm[4][0], '((1)*(('+term2_n+'*((sto)**2))*'+term2_n+'))*(-1)') self.assertEqual(Q_cm[4][1], '((1)*(('+term2_p+'*((sto)**2))*'+term2_p+'))*(-1)') self.assertEqual(Q_cm[4][2], 0) self.assertEqual(Q_cm[4][3], 0) self.assertEqual(Q_cm[4][4], '((1)*(('+term2_p+'*((sto)**2))*'+term2_p+'))*(1) + ((1)*(('+term2_n+'*((sto)**2))*'+term2_n+'))*(1)') self.assertEqual(Q_cm[4][5], 0) self.assertEqual(Q_cm[5][0], '((1)*(('+term1_n+'*((sto)**2))*'+term1_n+'))*(1)') self.assertEqual(Q_cm[5][1], 0) self.assertEqual(Q_cm[5][2], '((1)*(('+term1_n+'*((sto)**2))*'+term1_n+'))*(-1)') self.assertEqual(Q_cm[5][3], 0) self.assertEqual(Q_cm[5][4], 0) self.assertEqual(Q_cm[5][5], '((1)*(('+term1_n+'*((sto)**2))*'+term1_n+'))*(1)') def test_jac(self): step_ode_sde = self.m_noise.step_ode_sde() jac = self.m_diff.jac(step_ode_sde['sf']) # testing jac # I ode - ((v)*I) - ((mu_d)*I) + ((r0/N*v*I)*S) self.assertEqual(jac['caches'][jac['jac'][0][0]], '-gsl_spline_eval(calc->spline[ORDER_mu_d_nyc],t,calc->acc[ORDER_mu_d_nyc])-(gsl_vector_get(par,ORDER_v))+X[ORDER_S_nyc]*diffed[ORDER_diff__r0_nyc]*gsl_vector_get(par,ORDER_v)/gsl_spline_eval(calc->spline[ORDER_N_nyc],t,calc->acc[ORDER_N_nyc])') self.assertEqual(jac['caches'][jac['jac'][1][1]], '-gsl_spline_eval(calc->spline[ORDER_mu_d_paris],t,calc->acc[ORDER_mu_d_paris])-(gsl_vector_get(par,ORDER_v))+X[ORDER_S_paris]*diffed[ORDER_diff__r0_paris]*gsl_vector_get(par,ORDER_v)/gsl_spline_eval(calc->spline[ORDER_N_paris],t,calc->acc[ORDER_N_paris])') self.assertEqual(jac['caches'][jac['jac_diff'][1][0]['value']], '0') self.assertEqual(jac['caches'][jac['jac_diff'][0][1]['value']], '0') # S ode - ((r0/N*v*I)*S) - ((mu_d)*S) + (mu_b*N) self.assertEqual(jac['caches'][jac['jac'][2][2]], '-X[ORDER_I_nyc]*diffed[ORDER_diff__r0_nyc]*gsl_vector_get(par,ORDER_v)/gsl_spline_eval(calc->spline[ORDER_N_nyc],t,calc->acc[ORDER_N_nyc])-gsl_spline_eval(calc->spline[ORDER_mu_d_nyc],t,calc->acc[ORDER_mu_d_nyc])') self.assertEqual(jac['caches'][jac['jac'][3][3]], '-X[ORDER_I_paris]*diffed[ORDER_diff__r0_paris]*gsl_vector_get(par,ORDER_v)/gsl_spline_eval(calc->spline[ORDER_N_paris],t,calc->acc[ORDER_N_paris])-gsl_spline_eval(calc->spline[ORDER_mu_d_paris],t,calc->acc[ORDER_mu_d_paris])') self.assertEqual(jac['caches'][jac['jac'][2][0]], '-X[ORDER_S_nyc]*diffed[ORDER_diff__r0_nyc]*gsl_vector_get(par,ORDER_v)/gsl_spline_eval(calc->spline[ORDER_N_nyc],t,calc->acc[ORDER_N_nyc])') self.assertEqual(jac['caches'][jac['jac'][3][1]], '-X[ORDER_S_paris]*diffed[ORDER_diff__r0_paris]*gsl_vector_get(par,ORDER_v)/gsl_spline_eval(calc->spline[ORDER_N_paris],t,calc->acc[ORDER_N_paris])') # testing jac_obs # all_inc self.assertEqual(jac['caches'][jac['jac_obs'][0][0]], 'gsl_spline_eval(calc->spline[ORDER_mu_d_nyc],t,calc->acc[ORDER_mu_d_nyc])+(gsl_vector_get(par,ORDER_v))') self.assertEqual(jac['caches'][jac['jac_obs'][0][1]], 'gsl_spline_eval(calc->spline[ORDER_mu_d_paris],t,calc->acc[ORDER_mu_d_paris])+(gsl_vector_get(par,ORDER_v))') self.assertEqual(jac['caches'][jac['jac_obs_diff'][0][0]['value']], '0') self.assertEqual(jac['caches'][jac['jac_obs_diff'][0][1]['value']], '0') # nyc_inc self.assertEqual(jac['caches'][jac['jac_obs'][1][0]], 'X[ORDER_S_nyc]*diffed[ORDER_diff__r0_nyc]*gsl_vector_get(par,ORDER_v)/gsl_spline_eval(calc->spline[ORDER_N_nyc],t,calc->acc[ORDER_N_nyc])') self.assertEqual(jac['caches'][jac['jac_obs'][1][1]], '0') self.assertEqual(jac['caches'][jac['jac_obs_diff'][1][0]['value']], 'X[ORDER_I_nyc]*X[ORDER_S_nyc]*gsl_vector_get(par,ORDER_v)/gsl_spline_eval(calc->spline[ORDER_N_nyc],t,calc->acc[ORDER_N_nyc])') self.assertEqual(jac['caches'][jac['jac_obs_diff'][1][1]['value']], '0') def test_cache_special_function_C(self): caches = map(lambda x: self.m_diff.make_C_term(x, False), ['sin(2*PI*(t +r0))', 'sin(2*PI*(t +r0))', 'sin(2*PI*(t +r0)) + correct_rate(v)']) sf = self.m_diff.cache_special_function_C(caches) self.assertEqual(sf, ['sin(2*PI*(r0+t))', 'ssm_correct_rate(gsl_vector_get(par,ORDER_v),dt)']) self.assertEqual(caches, ['_sf[0]', '_sf[0]', '_sf[1]+_sf[0]']) def test_cache_special_function_C_nested(self): caches = map(lambda x: self.m_diff.make_C_term(x, False), ['pow(correct_rate(correct_rate(v)), pow(2,4))']) sf = self.m_diff.cache_special_function_C(caches) self.assertEqual(sf, ['pow(ssm_correct_rate(ssm_correct_rate(gsl_vector_get(par,ORDER_v),dt),dt),pow(2,4))']) self.assertEqual(caches, ['_sf[0]'])
class TestCcoder(unittest.TestCase): def setUp(self): c = json.load(open(os.path.join('example', 'drift', 'context.json'))) p = json.load(open(os.path.join('example', 'drift', 'process.json'))) l = json.load(open(os.path.join('example', 'drift', 'link.json'))) self.m_drift = Ccoder(c, p, l) c = json.load(open(os.path.join('example', 'noise', 'context.json'))) p = json.load(open(os.path.join('example', 'noise', 'process.json'))) l = json.load(open(os.path.join('example', 'noise', 'link.json'))) self.m_noise = Ccoder(c, p, l) p = json.load(open(os.path.join('example', 'noise', 'process.json'))) p["white_noise"][0]["reaction"][0] = {'to':'S','from':'U'} self.m_noise2 = Ccoder(c, p, l) p = json.load(open(os.path.join('example', 'noise', 'process.json'))) p["white_noise"][0]["reaction"][0] = {'to':'R','from':'I'} self.m_noise3 = Ccoder(c, p, l) p = json.load(open(os.path.join('example', 'noise', 'process.json'))) p["white_noise"][0]["reaction"][0] = {'to':'U','from':'I'} self.m_noise4 = Ccoder(c, p, l) p = json.load(open(os.path.join('example', 'noise', 'process.json'))) p["model"].append({"from": "R", "to": "U", "rate": "mu_d", "comment":"death"}) p["white_noise"][0]["reaction"][0] = {'to':'U','from':'R'} self.m_noise5 = Ccoder(c, p, l) p = json.load(open(os.path.join('example', 'noise', 'process.json'))) p["white_noise"][0]["reaction"].append({'to':'R','from':'I'}) self.m_noise6 = Ccoder(c, p, l) p = json.load(open(os.path.join('example', 'noise', 'process.json'))) p["white_noise"].append({"reaction":[{'to':'R','from':'I'}],"sd":"sto"}) self.m_noise7 = Ccoder(c, p, l) p = json.load(open(os.path.join('example', 'drift', 'process.json'))) p["model"].append({"from": "R", "to": "I", "rate": "correct_rate(v)", "comment":"testing"}) self.m_drift2 = Ccoder(c, p, l) def test_make_C_term(self): terms = [ {'x': 'mu_b*(1.0+v*sin((v/N+(mu_b)))) + r0', #input 'h': 'mu_b*(v*sin(mu_b + v/N) + 1.0) + r0', #expected human output 'c': 'gsl_spline_eval(p_calc->spline[ORDER_mu_b][cac],t,p_calc->acc[ORDER_mu_b][cac])*(par[ORDER_v][routers[ORDER_v]->map[cac]]*sin(gsl_spline_eval(p_calc->spline[ORDER_mu_b][cac],t,p_calc->acc[ORDER_mu_b][cac])+par[ORDER_v][routers[ORDER_v]->map[cac]]/gsl_spline_eval(p_calc->spline[ORDER_N][cac],t,p_calc->acc[ORDER_N][cac]))+1.0)+drifted[ORDER_drift__par_proc__r0][cac]'}, #expected C output {'x': 'N-S-I+S+I', 'h': 'N', 'c': 'gsl_spline_eval(p_calc->spline[ORDER_N][cac],t,p_calc->acc[ORDER_N][cac])'}, {'x': 'rep*(1.0-rep)*prop*x + (rep*phi*prop*x)**2', 'h': 'pow(phi, 2)*pow(rep, 2)*pow(x, 2)*pow(prop, 2) + rep*x*prop*(-rep + 1.0)', 'c': 'pow(par[ORDER_phi][routers[ORDER_phi]->map[ts]],2)*pow(par[ORDER_rep][routers[ORDER_rep]->map[ts]],2)*pow(x,2)*pow(gsl_spline_eval(p_calc->spline[ORDER_prop][ts],t,p_calc->acc[ORDER_prop][ts]),2)+par[ORDER_rep][routers[ORDER_rep]->map[ts]]*x*gsl_spline_eval(p_calc->spline[ORDER_prop][ts],t,p_calc->acc[ORDER_prop][ts])*(-par[ORDER_rep][routers[ORDER_rep]->map[ts]]+1.0)'}, ] for t in terms: self.assertEqual(self.m_drift.make_C_term(t['x'], False, human=True), t['h']) self.assertEqual(self.m_drift.make_C_term(t['x'], False, human=False), t['c']) def test_make_C_term_derivate(self): x = 'sin(2*M_PI*(t/ONE_YEAR +r0))' h = '2*M_PI*cos(2*M_PI*(r0 + t/ONE_YEAR))' c = '2*M_PI*cos(2*M_PI*(drifted[ORDER_drift__par_proc__r0][cac]+t/ONE_YEAR))' self.assertEqual(self.m_drift.make_C_term(x, False, human=True, derivate='r0'), h) self.assertEqual(self.m_drift.make_C_term(x, False, human=False, derivate='r0'), c) def test_make_C_term_skip_correct_rate(self): #correct_rate is only skipped for C code x = 'mu_b*(1.0+correct_rate(v)*sin((correct_rate(v)/N+(mu_b)))) + r0' c = 'gsl_spline_eval(p_calc->spline[ORDER_mu_b][cac],t,p_calc->acc[ORDER_mu_b][cac])*((par[ORDER_v][routers[ORDER_v]->map[cac]])*sin(gsl_spline_eval(p_calc->spline[ORDER_mu_b][cac],t,p_calc->acc[ORDER_mu_b][cac])+(par[ORDER_v][routers[ORDER_v]->map[cac]])/gsl_spline_eval(p_calc->spline[ORDER_N][cac],t,p_calc->acc[ORDER_N][cac]))+1.0)+drifted[ORDER_drift__par_proc__r0][cac]' self.assertEqual(self.m_drift.make_C_term(x, True, human=False), c) def test_make_C_term_extra_terms(self): terms = [ {'x': 'terms_forcing(v)', 'c': 'terms_forcing(par[ORDER_v][routers[ORDER_v]->map[cac]],t,p_data,cac)'}, {'x': 'heaviside(t-v)', 'c': 'heaviside(t-par[ORDER_v][routers[ORDER_v]->map[cac]])'}, {'x': 'heaviside((t-v))', 'c': 'heaviside(t-par[ORDER_v][routers[ORDER_v]->map[cac]])'}, {'x': 'ramp(t-v)', 'c': 'ramp(t-par[ORDER_v][routers[ORDER_v]->map[cac]])'}, {'x': 'correct_rate(v)', 'c': 'correct_rate(par[ORDER_v][routers[ORDER_v]->map[cac]],dt)'}, ] for t in terms: self.assertEqual(self.m_drift.make_C_term(t['x'], False, human=False), t['c']) def test_cache_special_function_C(self): caches = map(lambda x: self.m_drift.make_C_term(x, True), ['sin(2*M_PI*(t/ONE_YEAR +r0))', 'sin(2*M_PI*(t/ONE_YEAR +r0))', 'terms_forcing(v)*sin(2*M_PI*(t/ONE_YEAR +r0))*terms_forcing(v)']) sf = self.m_drift.cache_special_function_C(caches, prefix='_sf[cac]') self.assertEqual(sf, ['sin(2*M_PI*(drifted[ORDER_drift__par_proc__r0][cac]+t/ONE_YEAR))', 'terms_forcing(par[ORDER_v][routers[ORDER_v]->map[cac]],t,p_data,cac)']) self.assertEqual(caches, ['_sf[cac][0]', '_sf[cac][0]', 'pow(_sf[cac][1],2)*_sf[cac][0]']) def test_eval_Q(self): calc_Q = self.m_noise.eval_Q() # testing env sto only term = '((((r0/N*v*I)*S)*((sto)**2))*((r0/N*v*I)*S)))' self.assertEqual(calc_Q["no_dem_sto"]["Q"][0][0],'((-1)*'+term+'*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][0][1],'((-1)*'+term+'*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][0][2],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][0][3],'((-1)*'+term+'*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][0][4],'((-1)*'+term+'*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][1][0],'((1)*'+term+'*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][1][1],'((1)*'+term+'*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][1][2],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][1][3],'((1)*'+term+'*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][1][4],'((1)*'+term+'*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][2][0],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][2][1],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][2][2],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][2][3],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][2][4],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][3][0],'((1)*'+term+'*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][3][1],'((1)*'+term+'*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][3][2],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][3][3],'((1)*'+term+'*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][3][4],'((1)*'+term+'*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][4][0],'((1)*'+term+'*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][4][1],'((1)*'+term+'*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][4][2],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][4][3],'((1)*'+term+'*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][4][4],'((1)*'+term+'*(1)') # testing dem sto only term1 = '(mu_b*N))' term2 = '((r0/N*v*I)*S))' term3 = '((correct_rate(v))*I))' term4 = '((mu_d)*S))' term5 = '((mu_d)*I))' self.assertEqual(calc_Q["no_env_sto"]["Q"][0][0],'((1)*'+term1+'*(1) + ((-1)*'+term2+'*(-1) + ((-1)*'+term4+'*(-1)') self.assertEqual(calc_Q["no_env_sto"]["Q"][0][1],'((-1)*'+term2+'*(1)') self.assertEqual(calc_Q["no_env_sto"]["Q"][0][2],0) self.assertEqual(calc_Q["no_env_sto"]["Q"][0][3],'((-1)*'+term2+'*(1)') self.assertEqual(calc_Q["no_env_sto"]["Q"][0][4],'((-1)*'+term2+'*(1)') self.assertEqual(calc_Q["no_env_sto"]["Q"][1][0],'((1)*'+term2+'*(-1)') self.assertEqual(calc_Q["no_env_sto"]["Q"][1][1],'((1)*'+term2+'*(1) + ((-1)*'+term3+'*(-1) + ((-1)*'+term5+'*(-1)' ) self.assertEqual(calc_Q["no_env_sto"]["Q"][1][2],'((-1)*'+term3+'*(1) + ((-1)*'+term5+'*(1)') self.assertEqual(calc_Q["no_env_sto"]["Q"][1][3],'((1)*'+term2+'*(1)') self.assertEqual(calc_Q["no_env_sto"]["Q"][1][4],'((1)*'+term2+'*(1) + ((-1)*'+term3+'*(-1) + ((-1)*'+term5+'*(-1)') self.assertEqual(calc_Q["no_env_sto"]["Q"][2][0],0) self.assertEqual(calc_Q["no_env_sto"]["Q"][2][1],'((1)*'+term3+'*(-1) + ((1)*'+term5+'*(-1)') self.assertEqual(calc_Q["no_env_sto"]["Q"][2][2],'((1)*'+term3+'*(1) + ((1)*'+term5+'*(1)') self.assertEqual(calc_Q["no_env_sto"]["Q"][2][3],0) self.assertEqual(calc_Q["no_env_sto"]["Q"][2][4],'((1)*'+term3+'*(-1) + ((1)*'+term5+'*(-1)') self.assertEqual(calc_Q["no_env_sto"]["Q"][3][0],'((1)*'+term2+'*(-1)') self.assertEqual(calc_Q["no_env_sto"]["Q"][3][1],'((1)*'+term2+'*(1)') self.assertEqual(calc_Q["no_env_sto"]["Q"][3][2],0) self.assertEqual(calc_Q["no_env_sto"]["Q"][3][3],'((1)*'+term2+'*(1)') self.assertEqual(calc_Q["no_env_sto"]["Q"][3][4],'((1)*'+term2+'*(1)') self.assertEqual(calc_Q["no_env_sto"]["Q"][4][0],'((1)*'+term2+'*(-1)') self.assertEqual(calc_Q["no_env_sto"]["Q"][4][1],'((1)*'+term2+'*(1) + ((-1)*'+term3+'*(-1) + ((-1)*'+term5+'*(-1)') self.assertEqual(calc_Q["no_env_sto"]["Q"][4][2],'((-1)*'+term3+'*(1) + ((-1)*'+term5+'*(1)') self.assertEqual(calc_Q["no_env_sto"]["Q"][4][3],'((1)*'+term2+'*(1)') self.assertEqual(calc_Q["no_env_sto"]["Q"][4][4],'((1)*'+term2+'*(1) + ((-1)*'+term3+'*(-1) + ((-1)*'+term5+'*(-1)') #print(calc_Q["no_env_sto"]["Q_proc"]) def test_eval_Q_tricky_cases(self): calc_Q = self.m_noise2.eval_Q() # testing env sto only for m_noise2 : WN on U->S term = '(((mu_b*N)*((sto)**2))*(mu_b*N)))' for i in range(5): for j in range(5): if i==0 and j == 0: self.assertEqual(calc_Q["no_dem_sto"]["Q"][i][j],'((1)*'+term+'*(1)') else: self.assertEqual(calc_Q["no_dem_sto"]["Q"][i][j],0) calc_Q = self.m_noise3.eval_Q() # testing env sto only for m_noise3 : WN on I->R term = '((((correct_rate(v))*I)*((sto)**2))*((correct_rate(v))*I)))' self.assertEqual(calc_Q["no_dem_sto"]["Q"][0][0],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][0][1],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][0][2],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][0][3],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][0][4],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][1][0],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][1][1],'((-1)*'+term+'*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][1][2],'((-1)*'+term+'*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][1][3],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][1][4],'((-1)*'+term+'*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][2][0],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][2][1],'((1)*'+term+'*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][2][2],'((1)*'+term+'*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][2][3],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][2][4],'((1)*'+term+'*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][3][0],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][3][1],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][3][2],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][3][3],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][3][4],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][4][0],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][4][1],'((-1)*'+term+'*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][4][2],'((-1)*'+term+'*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][4][3],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][4][4],'((-1)*'+term+'*(-1)') calc_Q = self.m_noise4.eval_Q() # testing env sto only for m_noise4 : WN on I->U term = '((((mu_d)*I)*((sto)**2))*((mu_d)*I)))' self.assertEqual(calc_Q["no_dem_sto"]["Q"][0][0],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][0][1],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][0][2],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][0][3],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][0][4],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][1][0],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][1][1],'((-1)*'+term+'*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][1][2],'((-1)*'+term+'*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][1][3],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][1][4],'((-1)*'+term+'*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][2][0],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][2][1],'((1)*'+term+'*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][2][2],'((1)*'+term+'*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][2][3],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][2][4],'((1)*'+term+'*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][3][0],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][3][1],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][3][2],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][3][3],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][3][4],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][4][0],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][4][1],'((-1)*'+term+'*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][4][2],'((-1)*'+term+'*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][4][3],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][4][4],'((-1)*'+term+'*(-1)') calc_Q = self.m_noise5.eval_Q() # testing env sto only for m_noise5 : WN on R->U for i in range(5): for j in range(5): self.assertEqual(calc_Q["no_dem_sto"]["Q"][i][j],0) calc_Q = self.m_noise6.eval_Q() # testing env sto only for m_noise6 : correlated WN on I->R and S->I term1 = '((r0/N*v*I)*S)' term2 = '((correct_rate(v))*I)' self.assertEqual(calc_Q["no_dem_sto"]["Q"][0][0],'((-1)*(('+term1+'*((sto)**2))*'+term1+'))*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][0][1],'((-1)*(('+term1+'*((sto)**2))*'+term1+'))*(1) + ((-1)*(('+term1+'*((sto)**2))*'+term2+'))*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][0][2],'((-1)*(('+term1+'*((sto)**2))*'+term2+'))*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][0][3],'((-1)*(('+term1+'*((sto)**2))*'+term1+'))*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][0][4],'((-1)*(('+term1+'*((sto)**2))*'+term1+'))*(1) + ((-1)*(('+term1+'*((sto)**2))*'+term2+'))*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][1][0],'((1)*(('+term1+'*((sto)**2))*'+term1+') + (-1)*(('+term2+'*((sto)**2))*'+term1+'))*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][1][1],'((1)*(('+term1+'*((sto)**2))*'+term1+') + (-1)*(('+term2+'*((sto)**2))*'+term1+'))*(1) + ((1)*(('+term1+'*((sto)**2))*'+term2+') + (-1)*(('+term2+'*((sto)**2))*'+term2+'))*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][1][2],'((1)*(('+term1+'*((sto)**2))*'+term2+') + (-1)*(('+term2+'*((sto)**2))*'+term2+'))*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][1][3],'((1)*(('+term1+'*((sto)**2))*'+term1+') + (-1)*(('+term2+'*((sto)**2))*'+term1+'))*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][1][4],'((1)*(('+term1+'*((sto)**2))*'+term1+') + (-1)*(('+term2+'*((sto)**2))*'+term1+'))*(1) + ((1)*(('+term1+'*((sto)**2))*'+term2+') + (-1)*(('+term2+'*((sto)**2))*'+term2+'))*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][2][0],'((1)*(('+term2+'*((sto)**2))*'+term1+'))*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][2][1],'((1)*(('+term2+'*((sto)**2))*'+term1+'))*(1) + ((1)*(('+term2+'*((sto)**2))*'+term2+'))*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][2][2],'((1)*(('+term2+'*((sto)**2))*'+term2+'))*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][2][3],'((1)*(('+term2+'*((sto)**2))*'+term1+'))*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][2][4],'((1)*(('+term2+'*((sto)**2))*'+term1+'))*(1) + ((1)*(('+term2+'*((sto)**2))*'+term2+'))*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][3][0],'((1)*(('+term1+'*((sto)**2))*'+term1+'))*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][3][1],'((1)*(('+term1+'*((sto)**2))*'+term1+'))*(1) + ((1)*(('+term1+'*((sto)**2))*'+term2+'))*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][3][2],'((1)*(('+term1+'*((sto)**2))*'+term2+'))*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][3][3],'((1)*(('+term1+'*((sto)**2))*'+term1+'))*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][3][4],'((1)*(('+term1+'*((sto)**2))*'+term1+'))*(1) + ((1)*(('+term1+'*((sto)**2))*'+term2+'))*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][4][0],'((1)*(('+term1+'*((sto)**2))*'+term1+') + (-1)*(('+term2+'*((sto)**2))*'+term1+'))*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][4][1],'((1)*(('+term1+'*((sto)**2))*'+term1+') + (-1)*(('+term2+'*((sto)**2))*'+term1+'))*(1) + ((1)*(('+term1+'*((sto)**2))*'+term2+') + (-1)*(('+term2+'*((sto)**2))*'+term2+'))*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][4][2],'((1)*(('+term1+'*((sto)**2))*'+term2+') + (-1)*(('+term2+'*((sto)**2))*'+term2+'))*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][4][3],'((1)*(('+term1+'*((sto)**2))*'+term1+') + (-1)*(('+term2+'*((sto)**2))*'+term1+'))*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][4][4],'((1)*(('+term1+'*((sto)**2))*'+term1+') + (-1)*(('+term2+'*((sto)**2))*'+term1+'))*(1) + ((1)*(('+term1+'*((sto)**2))*'+term2+') + (-1)*(('+term2+'*((sto)**2))*'+term2+'))*(-1)') calc_Q = self.m_noise7.eval_Q() # testing env sto only for m_noise7 : uncorrelated WN on I->R and S->I term1 = '((r0/N*v*I)*S)' term2 = '((correct_rate(v))*I)' self.assertEqual(calc_Q["no_dem_sto"]["Q"][0][0],'((-1)*(('+term1+'*((sto)**2))*'+term1+'))*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][0][1],'((-1)*(('+term1+'*((sto)**2))*'+term1+'))*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][0][2],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][0][3],'((-1)*(('+term1+'*((sto)**2))*'+term1+'))*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][0][4],'((-1)*(('+term1+'*((sto)**2))*'+term1+'))*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][1][0],'((1)*(('+term1+'*((sto)**2))*'+term1+'))*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][1][1],'((1)*(('+term1+'*((sto)**2))*'+term1+'))*(1) + ((-1)*(('+term2+'*((sto)**2))*'+term2+'))*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][1][2],'((-1)*(('+term2+'*((sto)**2))*'+term2+'))*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][1][3],'((1)*(('+term1+'*((sto)**2))*'+term1+'))*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][1][4],'((1)*(('+term1+'*((sto)**2))*'+term1+'))*(1) + ((-1)*(('+term2+'*((sto)**2))*'+term2+'))*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][2][0],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][2][1],'((1)*(('+term2+'*((sto)**2))*'+term2+'))*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][2][2],'((1)*(('+term2+'*((sto)**2))*'+term2+'))*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][2][3],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][2][4],'((1)*(('+term2+'*((sto)**2))*'+term2+'))*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][3][0],'((1)*(('+term1+'*((sto)**2))*'+term1+'))*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][3][1],'((1)*(('+term1+'*((sto)**2))*'+term1+'))*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][3][2],0) self.assertEqual(calc_Q["no_dem_sto"]["Q"][3][3],'((1)*(('+term1+'*((sto)**2))*'+term1+'))*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][3][4],'((1)*(('+term1+'*((sto)**2))*'+term1+'))*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][4][0],'((1)*(('+term1+'*((sto)**2))*'+term1+'))*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][4][1],'((1)*(('+term1+'*((sto)**2))*'+term1+'))*(1) + ((-1)*(('+term2+'*((sto)**2))*'+term2+'))*(-1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][4][2],'((-1)*(('+term2+'*((sto)**2))*'+term2+'))*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][4][3],'((1)*(('+term1+'*((sto)**2))*'+term1+'))*(1)') self.assertEqual(calc_Q["no_dem_sto"]["Q"][4][4],'((1)*(('+term1+'*((sto)**2))*'+term1+'))*(1) + ((-1)*(('+term2+'*((sto)**2))*'+term2+'))*(-1)') def test_jac(self): step_ode_sde = self.m_drift.step_ode_sde() jac = self.m_drift.jac(step_ode_sde['sf']) # testing jac # S ode - ((r0/N*v*I)*S) - ((mu_d)*S) + (mu_b*N) self.assertEqual(jac["caches"][jac["jac"][0][0]],self.m_drift.make_C_term('- ((r0/N*v*I)) - ((mu_d))', False, human=False)) self.assertEqual(jac["caches"][jac["jac"][0][1]],self.m_drift.make_C_term('- ((r0/N*v)*S)', False, human=False)) self.assertEqual(jac["caches"][jac["jac_drift"][0][0]["value"]],self.m_drift.make_C_term('- ((1/N*v*I)*S)', False, human=False)) # the derivative is computed with regards to r0 and not transf(r0), as the latter is taken care of on runtime because it depends on the transformation. # I ode - ((v)*I) - ((mu_d)*I) + ((r0/N*v*I)*S) self.assertEqual(jac["caches"][jac["jac"][1][0]],self.m_drift.make_C_term(' ((r0/N*v*I)) ', False, human=False)) self.assertEqual(jac["caches"][jac["jac"][1][1]],self.m_drift.make_C_term('- ((v)) - ((mu_d)) + ((r0/N*v)*S)', False, human=False)) self.assertEqual(jac["caches"][jac["jac_drift"][1][0]["value"]],self.m_drift.make_C_term('((1/N*v*I)*S)', False, human=False)) # testing jac_obs # inc_out ((v)*I) + ((mu_d)*I) self.assertEqual(jac["caches"][jac["jac_obs"][0][0]],self.m_drift.make_C_term('0', False, human=False)) self.assertEqual(jac["caches"][jac["jac_obs"][0][1]],self.m_drift.make_C_term('((v)) + ((mu_d))', False, human=False)) self.assertEqual(jac["caches"][jac["jac_obs_drift"][0][0]["value"]],self.m_drift.make_C_term('0', False, human=False)) # inc_in ((r0/N*v*I)*S) self.assertEqual(jac["caches"][jac["jac_obs"][1][0]],self.m_drift.make_C_term('((r0/N*v*I))', False, human=False)) self.assertEqual(jac["caches"][jac["jac_obs"][1][1]],self.m_drift.make_C_term('((r0/N*v)*S)', False, human=False)) self.assertEqual(jac["caches"][jac["jac_obs_drift"][1][0]["value"]],self.m_drift.make_C_term('((1/N*v*I)*S)', False, human=False)) # prev - ((v)*I) - ((mu_d)*I) + ((r0/N*v*I)*S) self.assertEqual(jac["caches"][jac["jac_obs"][2][0]],self.m_drift.make_C_term('((r0/N*v*I))', False, human=False)) self.assertEqual(jac["caches"][jac["jac_obs"][2][1]],self.m_drift.make_C_term('- ((v)) - ((mu_d)) + ((r0/N*v)*S)', False, human=False)) self.assertEqual(jac["caches"][jac["jac_obs_drift"][2][0]["value"]],self.m_drift.make_C_term('((1/N*v*I)*S)', False, human=False)) def test_jac_tricky_cases(self): # testing if remainder is well dealt with step_ode_sde = self.m_drift2.step_ode_sde() jac = self.m_drift2.jac(step_ode_sde['sf']) # jac_obs # prev - ((v)*I) - ((mu_d)*I) + ((r0/N*v*I)*S) + ((correct_rate(v))*(N-S-I)) self.assertEqual(jac["caches"][jac["jac_obs"][2][0]],self.m_drift.make_C_term('((r0/N*v*I)) - correct_rate(v)', True, human=False)) self.assertEqual(jac["caches"][jac["jac_obs"][2][1]],self.m_drift.make_C_term('- ((v)) - ((mu_d)) + ((r0/N*v)*S) - correct_rate(v)', True, human=False)) self.assertEqual(jac["caches"][jac["jac_obs_drift"][2][0]["value"]],self.m_drift.make_C_term('((1/N*v*I)*S)', True, human=False))