def test_initialize(): """ test for the hops trajectory initialize function """ # Checks to make sure storage is AdaptiveTrajectoryStorage when calculation is adaptive hops = HOPS( sys_param, noise_param=noise_param, hierarchy_param=hier_param, eom_param=eom_param, integration_param=integrator_param, ) hops.make_adaptive() hops.initialize(psi_0) storage = hops.storage ATS = AdapTrajStorage() assert type(storage) == type(ATS) # Checks to make sure storage is TrajectoryStorage when calculation is non-adaptive hops = HOPS( sys_param, noise_param=noise_param, hierarchy_param=hier_param, eom_param=eom_param, integration_param=integrator_param, ) hops.initialize(psi_0) storage = hops.storage TS = TrajStorage() assert type(storage) == type(TS) # Checks to make sure noise was properly initialized t_axis = np.array([0, 1, 2, 3, 4], dtype=np.float64) noise = np.array([[1, 2, 2, 1, 3], [2, 3, 3, 2, 4]], dtype=np.float64) NumNT = NNT(noise, t_axis) noise = hops.noise1._noise known_noise = NumNT assert type(noise) == type(known_noise) ZN = ZeroNoise(noise_param, hops.basis.system.param) a = ZN b = hops.noise2 assert type(a) == type(b) # checks to make sure correct dimensions are stored N_dim = hops.storage.n_dim known = 2 assert N_dim == known # checks to make sure calculation is locked after initializing lock = hops.__initialized__ known_lock = True assert lock == known_lock
def test_make_adaptive_both_true(): """ Test to check if make_adaptive, with values of 0, is called that the proper DELTA_S dictionary values are stored """ hops = HOPS( sys_param, noise_param=noise_param, hierarchy_param=hier_param, eom_param=eom_param, integration_param=integrator_param, ) hops.make_adaptive(delta_h=1e-4, delta_s=1e-4) adap = hops.basis.eom.param["ADAPTIVE"] known_adap = True assert adap == known_adap adap_h = hops.basis.eom.param["ADAPTIVE_H"] known_adap_h = True assert adap_h == known_adap_h adap_s = hops.basis.eom.param["ADAPTIVE_S"] known_adap_s = True assert adap_s == known_adap_s delta_s = hops.basis.eom.param["DELTA_S"] known_delta_s = 1e-4 assert delta_s == known_delta_s delta_h = hops.basis.eom.param["DELTA_H"] known_delta_h = 1e-4 assert delta_h == known_delta_h
def test_hops_adaptive_dynamics_full(): """ This is a test of the adaptive dynamics algorithm when threshold is small enough that all states and hierarchy are included. """ hops_ah = HOPS( sys_param, noise_param=noise_param, hierarchy_param={"MAXHIER": 2}, eom_param=eom_param, ) hops_ah.make_adaptive(1e-15, 0) hops_ah.initialize(psi_0) hops_ah.propagate(t_max, t_step) np.testing.assert_allclose(hops.psi_traj[33], hops_ah.psi_traj[33]) hops_as = HOPS( sys_param, noise_param=noise_param, hierarchy_param={"MAXHIER": 2}, eom_param=eom_param, ) hops_as.make_adaptive(0, 1e-100) hops_as.initialize(psi_0) hops_as.propagate(t_max, t_step) np.testing.assert_allclose(hops.psi_traj[33], hops_as.psi_traj[33]) hops_a = HOPS( sys_param, noise_param=noise_param, hierarchy_param={"MAXHIER": 2}, eom_param=eom_param, ) hops_a.make_adaptive(1e-15, 1e-100) hops_a.initialize(psi_0) hops_a.propagate(t_max, t_step) np.testing.assert_allclose(hops.psi_traj[33], hops_a.psi_traj[33])
def test_normalize_else(): """ test to make sure psi is being returned un-normalized when hops.basis.eom.normalized is False """ hops = HOPS( sys_param, noise_param=noise_param, hierarchy_param=hier_param, eom_param=eom_param, integration_param=integrator_param, ) hops.initialize([2, 3]) hops.basis.eom.normalized = False norm = hops.normalize([2, 3]) known_norm = [2, 3] assert np.allclose(norm, known_norm)
def test_normalize_if(): """ test to make sure psi is being returned normalized when hops.basis.eom.normalized is True """ hops = HOPS( sys_param, noise_param=noise_param, hierarchy_param=hier_param, eom_param=eom_param, integration_param=integrator_param, ) hops.initialize([2, 3]) hops.basis.eom.normalized = True norm = hops.normalize([2, 3]) known_norm = [0.5547002, 0.83205029] assert np.allclose(norm, known_norm)
def test_check_tau_step(): """ Test to make sure tau is within precision, which is a constant Our current Tau is 2.0 so at a tau of 2 it passes but if you try to introduce a smaller tau (1) it will not pass """ hops = HOPS( sys_param, noise_param=noise_param, hierarchy_param=hier_param, eom_param=eom_param, integration_param=integrator_param, ) tau_bool = hops._check_tau_step(2.0, precision) known_tau_bool = True assert tau_bool == known_tau_bool tau_bool = hops._check_tau_step(1.0, precision) known_tau_bool = False assert tau_bool == known_tau_bool
def linear_chain(nsite, sb_params, V, maxhier=3, seed=None): # Noise Dictionary noise_param = { "SEED": seed, "MODEL": "FFT_FILTER", "TLEN": 2100.0, # Units: fs "TAU": 1.0, # Units: fs "DIAGONAL": True, } # System Dictionary e_lambda = sb_params[0][0] gamma = sb_params[0][1] temp = sb_params[1] gamma_mark = sb_params[2] gw_sysbath, lop_list = const_gw_sysbath(nsite, e_lambda, gamma, temp, gamma_mark) hs = (np.eye(nsite, k=1) + np.eye(nsite, k=-1)) * V sys_param = { "HAMILTONIAN": np.array(hs, dtype=np.complex128), "GW_SYSBATH": gw_sysbath, "L_HIER": lop_list, "L_NOISE1": lop_list, "ALPHA_NOISE1": bcf_exp, "PARAM_NOISE1": gw_sysbath, } # eom dictionary eom_param = {"EQUATION_OF_MOTION": "NORMALIZED NONLINEAR"} # hierarchy dictionary hierarchy_param = { "MAXHIER": maxhier, "STATIC_FILTERS": [["Markovian", [False, True] * nsite]], } return HOPS( sys_param, noise_param=noise_param, hierarchy_param=hierarchy_param, eom_param=eom_param, )
def test_error_flux_up(): """ test for the error induced by neglecting flux from H_0 (or H_S) to auxiliaries with lower summed index in H_0^C. """ noise_param = { "SEED": 0, "MODEL": "FFT_FILTER", "TLEN": 250.0, # Units: fs "TAU": 1.0, # Units: fs } nsite = 2 e_lambda = 20.0 gamma = 50.0 temp = 140.0 (g_0, w_0) = bcf_convert_sdl_to_exp(e_lambda, gamma, 0.0, temp) loperator = np.zeros([2, 2, 2], dtype=np.float64) gw_sysbath = [] lop_list = [] for i in range(nsite): loperator[i, i, i] = 1.0 gw_sysbath.append([g_0, w_0]) lop_list.append(sp.sparse.coo_matrix(loperator[i])) gw_sysbath.append([-1j * np.imag(g_0), 500.0]) lop_list.append(loperator[i]) hs = np.zeros([nsite, nsite], dtype=np.float64) hs[0, 1] = 40 hs[1, 0] = 40 sys_param = { "HAMILTONIAN": np.array(hs, dtype=np.complex128), "GW_SYSBATH": gw_sysbath, "L_HIER": lop_list, "L_NOISE1": lop_list, "ALPHA_NOISE1": bcf_exp, "PARAM_NOISE1": gw_sysbath, } eom_param = {"EQUATION_OF_MOTION": "NORMALIZED NONLINEAR"} integrator_param = { "INTEGRATOR": "RUNGE_KUTTA", "INCHWORM": False, "INCHWORM_MIN": 5, } psi_0 = np.array([0.0] * nsite, dtype=np.complex) psi_0[1] = 1.0 psi_0 = psi_0 / np.linalg.norm(psi_0) hops_ad = HOPS( sys_param, noise_param=noise_param, hierarchy_param={"MAXHIER": 4}, eom_param=eom_param, integration_param=integrator_param, ) hops_ad.make_adaptive(1e-3, 1e-3) hops_ad.initialize(psi_0) error = hops_ad.basis.error_flux_up(hops_ad.phi) known_error = [[0, 0, 0], [0, 0, 0], [0.00941804, 0, 0], [0.09418041, 0, 0]] assert np.allclose(error, known_error)
def test_error_flux_down(): """ test for the error induced by neglecting flux from H_0 (or H_S) to auxiliaries with higher summed index in H_0^C. """ noise_param = { "SEED": 0, "MODEL": "FFT_FILTER", "TLEN": 250.0, # Units: fs "TAU": 1.0, # Units: fs } nsite = 2 e_lambda = 20.0 gamma = 50.0 temp = 140.0 (g_0, w_0) = bcf_convert_sdl_to_exp(e_lambda, gamma, 0.0, temp) loperator = np.zeros([2, 2, 2], dtype=np.float64) gw_sysbath = [] lop_list = [] for i in range(nsite): loperator[i, i, i] = 1.0 gw_sysbath.append([g_0, w_0]) lop_list.append(sp.sparse.coo_matrix(loperator[i])) gw_sysbath.append([-1j * np.imag(g_0), 500.0]) lop_list.append(loperator[i]) hs = np.zeros([nsite, nsite], dtype=np.float64) hs[0, 1] = 40 hs[1, 0] = 40 sys_param = { "HAMILTONIAN": np.array(hs, dtype=np.complex128), "GW_SYSBATH": gw_sysbath, "L_HIER": lop_list, "L_NOISE1": lop_list, "ALPHA_NOISE1": bcf_exp, "PARAM_NOISE1": gw_sysbath, } eom_param = {"EQUATION_OF_MOTION": "NORMALIZED NONLINEAR"} integrator_param = { "INTEGRATOR": "RUNGE_KUTTA", "INCHWORM": False, "INCHWORM_MIN": 5, } psi_0 = np.array([0.0] * nsite, dtype=np.complex) psi_0[1] = 1.0 psi_0 = psi_0 / np.linalg.norm(psi_0) hops_ad = HOPS( sys_param, noise_param=noise_param, hierarchy_param={"MAXHIER": 4}, eom_param=eom_param, integration_param=integrator_param, ) hops_ad.make_adaptive(1e-3, 1e-3) hops_ad.initialize(psi_0) error = hops_ad.basis.error_flux_down(hops_ad.phi, "H") known_error = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] assert np.allclose(error, known_error) hops_ad.propagate(4, 2) known_error = [ [ 0.00000000e00, 0.00000000e00, 0.00000000e00, 0.00000000e00, 0.00000000e00, 0.00000000e00, 0.00000000e00, 0.00000000e00, 0.00000000e00, 0.00000000e00, 0.00000000e00, 0.00000000e00, ], [ 0.00000000e00, 1.77300996e-06, 0.00000000e00, 0.00000000e00, 3.42275816e-07, 0.00000000e00, 0.00000000e00, 0.00000000e00, 0.00000000e00, 0.00000000e00, 0.00000000e00, 0.00000000e00, ], [ 0.00000000e00, 0.00000000e00, 1.11871052e-03, 0.00000000e00, 0.00000000e00, 3.12152420e-05, 3.51225702e-04, 0.00000000e00, 1.09725980e-04, 0.00000000e00, 3.31052922e-05, 0.00000000e00, ], [ 0.00000000e00, 0.00000000e00, 0.00000000e00, 2.36349134e-04, 0.00000000e00, 0.00000000e00, 8.74004868e-06, 7.42495639e-05, 2.73046762e-06, 2.30899011e-05, 8.23806071e-07, 7.44294797e-06, ], ] error = hops_ad.basis.error_flux_down(hops_ad.phi, "H") print(error) assert np.allclose(error, known_error)
"TIME_DEPENDENCE": False, "EQUATION_OF_MOTION": "NORMALIZED NONLINEAR" } integrator_param = { "INTEGRATOR": "RUNGE_KUTTA", "INCHWORM": True, "INCHWORM_MIN": 5 } psi_0 = [1.0 + 0.0 * 1j, 0.0 + 0.0 * 1j] hops = HOPS( sys_param, noise_param=noise_param, hierarchy_param=hier_param, eom_param=eom_param, integration_param=integrator_param, ) hops.initialize(psi_0) # Test basic functions # ---------------------- def test_l_avg_calculation(): lind_dict = hops.basis.system.param["LIST_L2_COO"] lop_list = lind_dict lavg_list = [operator_expectation(L2, hops.psi) for L2 in lop_list] assert lavg_list[0] == 1.0 assert lavg_list[1] == 0.0
def test_determine_error_thresh(): """ test to determine correct error value is set as the error threshold """ noise_param = { "SEED": 0, "MODEL": "FFT_FILTER", "TLEN": 250.0, # Units: fs "TAU": 1.0, # Units: fs } nsite = 10 e_lambda = 20.0 gamma = 50.0 temp = 140.0 (g_0, w_0) = bcf_convert_sdl_to_exp(e_lambda, gamma, 0.0, temp) loperator = np.zeros([10, 10, 10], dtype=np.float64) gw_sysbath = [] lop_list = [] for i in range(nsite): loperator[i, i, i] = 1.0 gw_sysbath.append([g_0, w_0]) lop_list.append(sp.sparse.coo_matrix(loperator[i])) gw_sysbath.append([-1j * np.imag(g_0), 500.0]) lop_list.append(loperator[i]) hs = np.zeros([nsite, nsite]) hs[0, 1] = 40 hs[1, 0] = 40 hs[1, 2] = 10 hs[2, 1] = 10 hs[2, 3] = 40 hs[3, 2] = 40 hs[3, 4] = 10 hs[4, 3] = 10 hs[4, 5] = 40 hs[5, 4] = 40 hs[5, 6] = 10 hs[6, 5] = 10 hs[6, 7] = 40 hs[7, 6] = 40 hs[7, 8] = 10 hs[8, 7] = 10 hs[8, 9] = 40 hs[9, 8] = 40 sys_param = { "HAMILTONIAN": np.array(hs, dtype=np.complex128), "GW_SYSBATH": gw_sysbath, "L_HIER": lop_list, "L_NOISE1": lop_list, "ALPHA_NOISE1": bcf_exp, "PARAM_NOISE1": gw_sysbath, } eom_param = {"EQUATION_OF_MOTION": "NORMALIZED NONLINEAR"} integrator_param = { "INTEGRATOR": "RUNGE_KUTTA", "INCHWORM": False, "INCHWORM_MIN": 5, } psi_0 = np.array([0.0] * nsite, dtype=np.complex) psi_0[5] = 1.0 psi_0 = psi_0 / np.linalg.norm(psi_0) hops_ad = HOPS( sys_param, noise_param=noise_param, hierarchy_param={"MAXHIER": 2}, eom_param=eom_param, integration_param=integrator_param, ) hops_ad.make_adaptive(1e-3, 1e-3) hops_ad.initialize(psi_0) # if test sorted_error = np.array([0, 1, 2, 3, 5]) max_error = 3.0 error = hops_ad.basis._determine_error_thresh(sorted_error, max_error) assert error == 2 # else test sorted_error = np.array([0, 1, 1, 3, 5]) max_error = 20.0 error = hops_ad.basis._determine_error_thresh(sorted_error, max_error) assert error == 0.0
def test_determine_boundary_hier(): """ Test to make sure correct boundary hierarchy members are accounted for """ noise_param = { "SEED": 0, "MODEL": "FFT_FILTER", "TLEN": 250.0, # Units: fs "TAU": 1.0, # Units: fs } nsite = 2 e_lambda = 20.0 gamma = 50.0 temp = 140.0 (g_0, w_0) = bcf_convert_sdl_to_exp(e_lambda, gamma, 0.0, temp) loperator = np.zeros([2, 2, 2], dtype=np.float64) gw_sysbath = [] lop_list = [] for i in range(nsite): loperator[i, i, i] = 1.0 gw_sysbath.append([g_0, w_0]) lop_list.append(sp.sparse.coo_matrix(loperator[i])) gw_sysbath.append([-1j * np.imag(g_0), 500.0]) lop_list.append(loperator[i]) hs = np.zeros([nsite, nsite], dtype=np.float64) hs[0, 1] = 40 hs[1, 0] = 40 sys_param = { "HAMILTONIAN": np.array(hs, dtype=np.complex128), "GW_SYSBATH": gw_sysbath, "L_HIER": lop_list, "L_NOISE1": lop_list, "ALPHA_NOISE1": bcf_exp, "PARAM_NOISE1": gw_sysbath, } eom_param = {"EQUATION_OF_MOTION": "NORMALIZED NONLINEAR"} integrator_param = { "INTEGRATOR": "RUNGE_KUTTA", "INCHWORM": False, "INCHWORM_MIN": 5, } psi_0 = np.array([0.0] * nsite, dtype=np.complex) psi_0[1] = 1.0 psi_0 = psi_0 / np.linalg.norm(psi_0) hops_ad = HOPS( sys_param, noise_param=noise_param, hierarchy_param={"MAXHIER": 4}, eom_param=eom_param, integration_param=integrator_param, ) hops_ad.make_adaptive(1e-3, 1e-3) hops_ad.initialize(psi_0) # Creating flux up and flux down matrices for initial hierarchy # flux down flux_down = np.zeros((4, 3)) # flux up flux_up = np.zeros((4, 3)) flux_up[2, 0] = 0.1 flux_up[3, 0] = 0.001 list_e2_kflux = np.array((flux_up, flux_down)) list_index_stable = [0, 1, 2] list_aux_up, list_aux_down = hops_ad.basis._determine_boundary_hier( list_e2_kflux, list_index_stable, 0.001 ) known_aux_up = [AuxiliaryVector([(2, 1)], 4)] assert list_aux_up == known_aux_up assert list_aux_down == [] # Creating flux up and flux down matrices for hierarchy after propagation hops_ad.propagate(4.0, 2.0) # flux up flux_up = np.zeros((4, 12)) flux_up[0, 0] = 0.01 flux_up[0, 6] = 0.01 flux_up[1, 7] = 0.00004 flux_up[2, 3] = 0.1 flux_up[2, 10] = 0.00007 flux_up[3, 9] = 0.0011 # flux down flux_down = np.zeros((4, 12)) flux_down[1, 1] = 0.1 flux_down[2, 2] = 0.1 flux_down[2, 10] = 0.1 flux_down[2, 6] = 0.00007 list_e2_kflux = np.array((flux_up, flux_down)) list_index_stable = [6, 4, 10, 11, 5, 7, 1, 9, 0, 3, 8, 2] list_index_stable.sort() list_aux_up, list_aux_down = hops_ad.basis._determine_boundary_hier( list_e2_kflux, list_index_stable, 0.001 ) known_aux_up = [ AuxiliaryVector([(0, 1)], 4), AuxiliaryVector([(0, 1), (2, 1), (3, 1)], 4), AuxiliaryVector([(2, 1), (3, 1)], 4), AuxiliaryVector([(3, 4)], 4), ] assert list_aux_up == known_aux_up assert list_aux_down == [ AuxiliaryVector([], 4), AuxiliaryVector([], 4), AuxiliaryVector([(3, 3)], 4), ]
def test_check_state_list(): """ Test to make sure check_state_list is giving out correct stable and bound states """ noise_param = { "SEED": 0, "MODEL": "FFT_FILTER", "TLEN": 250.0, # Units: fs "TAU": 1.0, # Units: fs } nsite = 10 e_lambda = 20.0 gamma = 50.0 temp = 140.0 (g_0, w_0) = bcf_convert_sdl_to_exp(e_lambda, gamma, 0.0, temp) loperator = np.zeros([10, 10, 10], dtype=np.float64) gw_sysbath = [] lop_list = [] for i in range(nsite): loperator[i, i, i] = 1.0 gw_sysbath.append([g_0, w_0]) lop_list.append(sp.sparse.coo_matrix(loperator[i])) gw_sysbath.append([-1j * np.imag(g_0), 500.0]) lop_list.append(loperator[i]) hs = np.zeros([nsite, nsite]) hs[0, 1] = 40 hs[1, 0] = 40 hs[1, 2] = 10 hs[2, 1] = 10 hs[2, 3] = 40 hs[3, 2] = 40 hs[3, 4] = 10 hs[4, 3] = 10 hs[4, 5] = 40 hs[5, 4] = 40 hs[5, 6] = 10 hs[6, 5] = 10 hs[6, 7] = 40 hs[7, 6] = 40 hs[7, 8] = 10 hs[8, 7] = 10 hs[8, 9] = 40 hs[9, 8] = 40 sys_param = { "HAMILTONIAN": np.array(hs, dtype=np.complex128), "GW_SYSBATH": gw_sysbath, "L_HIER": lop_list, "L_NOISE1": lop_list, "ALPHA_NOISE1": bcf_exp, "PARAM_NOISE1": gw_sysbath, } eom_param = {"EQUATION_OF_MOTION": "NORMALIZED NONLINEAR"} integrator_param = { "INTEGRATOR": "RUNGE_KUTTA", "INCHWORM": False, "INCHWORM_MIN": 5, } psi_0 = np.array([0.0] * nsite, dtype=np.complex) psi_0[5] = 1.0 psi_0 = psi_0 / np.linalg.norm(psi_0) hops_ad = HOPS( sys_param, noise_param=noise_param, hierarchy_param={"MAXHIER": 2}, eom_param=eom_param, integration_param=integrator_param, ) hops_ad.make_adaptive(1e-3, 1e-3) hops_ad.initialize(psi_0) # before propagation z_step = np.zeros(10) list_index_aux_stable = [0, 1, 2] list_stable_state, list_state_bound = hops_ad.basis._check_state_list( hops_ad.phi, 2.0, z_step, list_index_aux_stable ) known_states = [4, 5, 6] assert np.array_equal(list_stable_state, known_states) assert np.array_equal(list_state_bound, []) # propagate hops_ad.propagate(10.0, 2.0) list_stable_state, list_state_bound = hops_ad.basis._check_state_list( hops_ad.phi, 2.0, z_step, list_index_aux_stable ) known_states = [4, 5, 6] assert np.array_equal(list_stable_state, known_states) known_boundary = [3, 7] assert np.array_equal(list_state_bound, known_boundary)
def test_inchworm_aux(): """ test for inchworm_integrate to make sure the aux are properly being added """ noise_param = { "SEED": 0, "MODEL": "FFT_FILTER", "TLEN": 250.0, # Units: fs "TAU": 1.0, # Units: fs } nsite = 2 e_lambda = 20.0 gamma = 50.0 temp = 140.0 (g_0, w_0) = bcf_convert_sdl_to_exp(e_lambda, gamma, 0.0, temp) loperator = np.zeros([2, 2, 2], dtype=np.float64) gw_sysbath = [] lop_list = [] for i in range(nsite): loperator[i, i, i] = 1.0 gw_sysbath.append([g_0, w_0]) lop_list.append(sp.sparse.coo_matrix(loperator[i])) gw_sysbath.append([-1j * np.imag(g_0), 500.0]) lop_list.append(loperator[i]) hs = np.zeros([nsite, nsite], dtype=np.float64) hs[0, 1] = 40 hs[1, 0] = 40 # hs[1, 2] = 10 # hs[2, 1] = 10 sys_param = { "HAMILTONIAN": np.array(hs, dtype=np.complex128), "GW_SYSBATH": gw_sysbath, "L_HIER": lop_list, "L_NOISE1": lop_list, "ALPHA_NOISE1": bcf_exp, "PARAM_NOISE1": gw_sysbath, } eom_param = {"EQUATION_OF_MOTION": "NORMALIZED NONLINEAR"} integrator_param = { "INTEGRATOR": "RUNGE_KUTTA", "INCHWORM": True, "INCHWORM_MIN": 5, } psi_0 = np.array([0.0] * nsite, dtype=np.complex) psi_0[1] = 1.0 psi_0 = psi_0 / np.linalg.norm(psi_0) hops_inchworm = HOPS( sys_param, noise_param=noise_param, hierarchy_param={"MAXHIER": 4}, eom_param=eom_param, integration_param=integrator_param, ) hops_inchworm.make_adaptive(1e-15, 1e-15) hops_inchworm.initialize(psi_0) aux_list = hops_inchworm.auxiliary_list known_aux_list = map_to_auxvec([(0, 0, 0, 0), (0, 0, 1, 0), (0, 0, 0, 1)]) assert set(aux_list) == set(known_aux_list) z_step = hops_inchworm._prepare_zstep(2.0, hops_inchworm.storage.z_mem) (state_update, aux_update) = hops_inchworm.basis.define_basis(hops_inchworm.phi, 2.0, z_step) # First inchworm # ---------------------------------------------------------------------------------- state_update, aux_update, phi = hops_inchworm.inchworm_integrate( state_update, aux_update, 2.0) aux_new = aux_update[0] known = map_to_auxvec([ (0, 0, 0, 0), (0, 0, 0, 1), (0, 0, 0, 2), (0, 0, 1, 0), (0, 0, 1, 1), (0, 0, 2, 0), (0, 1, 0, 0), (0, 1, 0, 1), (0, 1, 1, 0), (1, 0, 0, 0), (1, 0, 0, 1), (1, 0, 1, 0), ]) assert set(aux_new) == set(known) state_aux = aux_update[1] known = map_to_auxvec([(0, 0, 0, 1), (0, 0, 0, 0), (0, 0, 1, 0)]) assert set(state_aux) == set(known) add_aux = aux_update[2] known = map_to_auxvec([ (0, 0, 0, 2), (0, 0, 1, 1), (0, 0, 2, 0), (0, 1, 0, 0), (0, 1, 0, 1), (0, 1, 1, 0), (1, 0, 0, 0), (1, 0, 0, 1), (1, 0, 1, 0), ]) assert set(known) == set(add_aux) # Second inchworm # ---------------------------------------------------------------------------------- state_update, aux_update, phi = hops_inchworm.inchworm_integrate( state_update, aux_update, 2.0) aux_new = aux_update[0] known = map_to_auxvec([ (0, 0, 0, 0), (0, 0, 0, 1), (0, 0, 0, 2), (0, 0, 0, 3), (0, 0, 1, 0), (0, 0, 1, 1), (0, 0, 1, 2), (0, 0, 2, 0), (0, 0, 2, 1), (0, 0, 3, 0), (0, 1, 0, 0), (0, 1, 0, 1), (0, 1, 1, 0), (1, 0, 0, 0), (1, 0, 0, 1), (1, 0, 1, 0), (0, 1, 0, 2), (0, 1, 1, 0), (0, 1, 1, 1), (0, 1, 2, 0), (0, 2, 0, 0), (0, 2, 0, 1), (0, 2, 1, 0), (1, 0, 0, 0), (1, 0, 0, 1), (1, 0, 0, 2), (1, 0, 1, 0), (1, 0, 1, 1), (1, 0, 2, 0), (1, 1, 0, 0), (1, 1, 0, 1), (1, 1, 1, 0), (2, 0, 0, 0), (2, 0, 0, 1), (2, 0, 1, 0), ]) assert set(aux_new) == set(known) stable_aux = aux_update[1] known = map_to_auxvec([ (0, 0, 0, 0), (0, 0, 0, 1), (0, 0, 0, 2), (0, 0, 1, 0), (0, 0, 1, 1), (0, 0, 2, 0), (0, 1, 0, 0), (0, 1, 0, 1), (0, 1, 1, 0), (1, 0, 0, 0), (1, 0, 0, 1), (1, 0, 1, 0), ]) assert set(stable_aux) == set(known) add_aux = aux_update[2] known = map_to_auxvec([ (0, 0, 0, 3), (0, 0, 1, 2), (0, 0, 2, 1), (0, 0, 3, 0), (0, 1, 0, 2), (0, 1, 1, 1), (0, 1, 2, 0), (0, 2, 0, 0), (0, 2, 0, 1), (0, 2, 1, 0), (1, 0, 0, 2), (1, 0, 1, 1), (1, 0, 2, 0), (1, 1, 0, 0), (1, 1, 0, 1), (1, 1, 1, 0), (2, 0, 0, 0), (2, 0, 0, 1), (2, 0, 1, 0), ]) assert set(known) == set(add_aux) # Third inchworm # ---------------------------------------------------------------------------------- state_update, aux_update, phi = hops_inchworm.inchworm_integrate( state_update, aux_update, 2.0) aux_new = aux_update[0] known = map_to_auxvec([ (0, 0, 0, 0), (0, 0, 0, 1), (0, 0, 0, 2), (0, 0, 0, 3), (0, 0, 1, 0), (0, 0, 1, 1), (0, 0, 1, 2), (0, 0, 2, 0), (0, 0, 2, 1), (0, 0, 3, 0), (0, 1, 0, 0), (0, 1, 0, 1), (0, 1, 0, 2), (0, 1, 1, 0), (0, 1, 1, 1), (0, 1, 2, 0), (0, 2, 0, 0), (0, 2, 0, 1), (0, 2, 1, 0), (1, 0, 0, 0), (1, 0, 0, 1), (1, 0, 0, 2), (1, 0, 1, 0), (1, 0, 1, 1), (1, 0, 2, 0), (1, 1, 0, 0), (1, 1, 0, 1), (1, 1, 1, 0), (2, 0, 0, 0), (2, 0, 0, 1), (2, 0, 1, 0), (0, 0, 0, 4), (0, 0, 1, 3), (0, 0, 2, 2), (0, 0, 3, 1), (0, 0, 4, 0), (0, 1, 0, 3), (0, 1, 1, 2), (0, 1, 2, 1), (0, 1, 3, 0), (0, 2, 0, 2), (0, 2, 1, 1), (0, 2, 2, 0), (0, 3, 0, 0), (0, 3, 0, 1), (0, 3, 1, 0), (1, 0, 0, 3), (1, 0, 1, 2), (1, 0, 2, 1), (1, 0, 3, 0), (1, 1, 0, 2), (1, 1, 1, 1), (1, 1, 2, 0), (1, 2, 0, 0), (1, 2, 0, 1), (1, 2, 1, 0), (2, 0, 0, 2), (2, 0, 1, 1), (2, 1, 0, 0), (2, 1, 0, 1), (2, 1, 1, 0), (3, 0, 0, 0), (3, 0, 1, 0), (3, 0, 0, 1), (2, 0, 2, 0), ]) assert set(aux_new) == set(known) stable_aux = aux_update[1] known = map_to_auxvec([ (0, 0, 0, 0), (0, 0, 0, 1), (0, 0, 0, 2), (0, 0, 0, 3), (0, 0, 1, 0), (0, 0, 1, 1), (0, 0, 1, 2), (0, 0, 2, 0), (0, 0, 2, 1), (0, 0, 3, 0), (0, 1, 0, 0), (0, 1, 0, 1), (0, 1, 0, 2), (0, 1, 1, 0), (0, 1, 1, 1), (0, 1, 2, 0), (0, 2, 0, 0), (0, 2, 0, 1), (0, 2, 1, 0), (1, 0, 0, 0), (1, 0, 0, 1), (1, 0, 0, 2), (1, 0, 1, 0), (1, 0, 1, 1), (1, 0, 2, 0), (1, 1, 0, 0), (1, 1, 0, 1), (1, 1, 1, 0), (2, 0, 0, 0), (2, 0, 0, 1), (2, 0, 1, 0), ]) assert set(stable_aux) == set(known) add_aux = aux_update[2] known = map_to_auxvec([ (0, 0, 0, 4), (0, 0, 1, 3), (0, 0, 2, 2), (0, 0, 3, 1), (0, 0, 4, 0), (0, 1, 0, 3), (0, 1, 1, 2), (0, 1, 2, 1), (0, 1, 3, 0), (0, 2, 0, 2), (0, 2, 1, 1), (0, 2, 2, 0), (0, 3, 0, 0), (0, 3, 0, 1), (0, 3, 1, 0), (1, 0, 0, 3), (1, 0, 1, 2), (1, 0, 2, 1), (1, 0, 3, 0), (1, 1, 0, 2), (1, 1, 1, 1), (1, 1, 2, 0), (1, 2, 0, 0), (1, 2, 0, 1), (1, 2, 1, 0), (2, 0, 0, 2), (2, 0, 1, 1), (2, 1, 0, 0), (2, 1, 0, 1), (2, 1, 1, 0), (3, 0, 0, 0), (3, 0, 1, 0), (3, 0, 0, 1), (2, 0, 2, 0), ]) assert set(known) == set(add_aux)
def test_store_step(): """ Test to make sure that store_step is properly storing propagated values """ hops = HOPS( sys_param, noise_param=noise_param, hierarchy_param=hier_param, eom_param=eom_param, integration_param=integrator_param, ) hops.make_adaptive() hops.initialize(psi_0) hops.propagate(2.0, 2.0) # time test time = hops.storage.t known_time = 2.0 assert time == known_time # t_axis test t_axis = hops.storage.t_axis known_t_axis = [0, 2.0] assert np.array_equal(t_axis, known_t_axis) # z_mem test z_mem = hops.storage.z_mem known_z_mem = [ 3.76011140e-03 + 0.0j, 1.88182635e-03 + 0.0j, 1.77699341e-08 + 0.0j, 8.88915173e-09 + 0.0j, ] np.testing.assert_almost_equal(z_mem, known_z_mem, 8) # aux storage False aux = hops.storage.aux known_aux = [] np.array_equal(aux, known_aux) # state list test state = hops.storage.state_list known_state = [[0, 1], [0, 1]] assert np.array_equal(state, known_state) # phi test phi = hops.storage.phi assert len(phi) == hops.n_hier * hops.n_state assert isinstance(phi, type(np.array([]))) assert isinstance(phi[0], np.complex128) # psi test psi_traj = hops.storage.psi_traj known_psi_traj = [ [1.0 + 0.0j, 0j], [0.999992832 - 0.00042642j, -4.06990909e-06 - 0.00376226j], ] np.testing.assert_allclose(psi_traj[0], np.array([1.0 + 0.0j, 0j])) np.testing.assert_allclose(psi_traj[1], hops.psi) phi_traj = hops.storage.phi_traj known_phi_traj = [] assert np.array_equal(phi_traj, known_phi_traj)
def test_initialize(): """ Test for the hops_basis initialize function """ noise_param = { "SEED": 0, "MODEL": "FFT_FILTER", "TLEN": 250.0, # Units: fs "TAU": 1.0, # Units: fs } nsite = 10 e_lambda = 20.0 gamma = 50.0 temp = 140.0 (g_0, w_0) = bcf_convert_sdl_to_exp(e_lambda, gamma, 0.0, temp) loperator = np.zeros([10, 10, 10], dtype=np.float64) gw_sysbath = [] lop_list = [] for i in range(nsite): loperator[i, i, i] = 1.0 gw_sysbath.append([g_0, w_0]) lop_list.append(sp.sparse.coo_matrix(loperator[i])) gw_sysbath.append([-1j * np.imag(g_0), 500.0]) lop_list.append(loperator[i]) hs = np.zeros([nsite, nsite]) hs[0, 1] = 40 hs[1, 0] = 40 hs[1, 2] = 10 hs[2, 1] = 10 hs[2, 3] = 40 hs[3, 2] = 40 hs[3, 4] = 10 hs[4, 3] = 10 hs[4, 5] = 40 hs[5, 4] = 40 hs[5, 6] = 10 hs[6, 5] = 10 hs[6, 7] = 40 hs[7, 6] = 40 hs[7, 8] = 10 hs[8, 7] = 10 hs[8, 9] = 40 hs[9, 8] = 40 sys_param = { "HAMILTONIAN": np.array(hs, dtype=np.complex128), "GW_SYSBATH": gw_sysbath, "L_HIER": lop_list, "L_NOISE1": lop_list, "ALPHA_NOISE1": bcf_exp, "PARAM_NOISE1": gw_sysbath, } eom_param = {"EQUATION_OF_MOTION": "NORMALIZED NONLINEAR"} integrator_param = { "INTEGRATOR": "RUNGE_KUTTA", "INCHWORM": False, "INCHWORM_MIN": 5, } psi_0 = np.array([0.0] * nsite, dtype=np.complex) psi_0[5] = 1.0 psi_0 = psi_0 / np.linalg.norm(psi_0) # Adaptive Hops hops_ad = HOPS( sys_param, noise_param=noise_param, hierarchy_param={"MAXHIER": 2}, eom_param=eom_param, integration_param=integrator_param, ) hops_ad.make_adaptive(1e-3, 1e-3) hops_ad.initialize(psi_0) # Non-adaptive Hops hops = HOPS( sys_param, noise_param=noise_param, hierarchy_param={"MAXHIER": 1}, eom_param=eom_param, integration_param=integrator_param, ) hops.initialize(psi_0) # non adaptive hier_param = {"MAXHIER": 4} sys_param = {"N_HMODES": 4} HH = HHier(hier_param, sys_param) HH.initialize(False) aux_list = HH.auxiliary_list list_hier = hops.basis.hierarchy.auxiliary_list assert type(list_hier) == type(aux_list) known_state = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] assert np.array_equal(hops.basis.system.state_list, known_state) # adaptive hier_param = {"MAXHIER": 4} sys_param = {"N_HMODES": 4} HH = HHier(hier_param, sys_param) HH.initialize(True) aux_list = HH.auxiliary_list list_hier = hops_ad.basis.hierarchy.auxiliary_list assert type(list_hier) == type(aux_list) known_state = [4, 5, 6] assert np.array_equal(hops_ad.basis.system.state_list, known_state)
def test_update_basis(): """ Test to make sure the basis is getting properly updated and returning the updated phi and dsystem_dt """ noise_param = { "SEED": 0, "MODEL": "FFT_FILTER", "TLEN": 250.0, # Units: fs "TAU": 1.0, # Units: fs } nsite = 10 e_lambda = 20.0 gamma = 50.0 temp = 140.0 (g_0, w_0) = bcf_convert_sdl_to_exp(e_lambda, gamma, 0.0, temp) loperator = np.zeros([10, 10, 10], dtype=np.float64) gw_sysbath = [] lop_list = [] for i in range(nsite): loperator[i, i, i] = 1.0 gw_sysbath.append([g_0, w_0]) lop_list.append(sp.sparse.coo_matrix(loperator[i])) gw_sysbath.append([-1j * np.imag(g_0), 500.0]) lop_list.append(loperator[i]) hs = np.zeros([nsite, nsite]) hs[0, 1] = 40 hs[1, 0] = 40 hs[1, 2] = 10 hs[2, 1] = 10 hs[2, 3] = 40 hs[3, 2] = 40 hs[3, 4] = 10 hs[4, 3] = 10 hs[4, 5] = 40 hs[5, 4] = 40 hs[5, 6] = 10 hs[6, 5] = 10 hs[6, 7] = 40 hs[7, 6] = 40 hs[7, 8] = 10 hs[8, 7] = 10 hs[8, 9] = 40 hs[9, 8] = 40 sys_param = { "HAMILTONIAN": np.array(hs, dtype=np.complex128), "GW_SYSBATH": gw_sysbath, "L_HIER": lop_list, "L_NOISE1": lop_list, "ALPHA_NOISE1": bcf_exp, "PARAM_NOISE1": gw_sysbath, } eom_param = {"EQUATION_OF_MOTION": "NORMALIZED NONLINEAR"} integrator_param = { "INTEGRATOR": "RUNGE_KUTTA", "INCHWORM": False, "INCHWORM_MIN": 5, } psi_0 = np.array([0.0] * nsite, dtype=np.complex) psi_0[5] = 1.0 psi_0 = psi_0 / np.linalg.norm(psi_0) hops_ad = HOPS( sys_param, noise_param=noise_param, hierarchy_param={"MAXHIER": 4}, eom_param=eom_param, integration_param=integrator_param, ) hops_ad.make_adaptive(1e-3, 1e-3) hops_ad.initialize(psi_0) hops_ad.propagate(2, 2) # state update state_new = [3, 4, 5, 6, 7] state_stable = [4, 5, 6] state_bound = [3, 7] state_update = (state_new, state_stable, state_bound) # hierarchy update hier_new = [ AuxiliaryVector([], 20), AuxiliaryVector([(5, 1)], 20), AuxiliaryVector([(9, 1)], 20), AuxiliaryVector([(10, 1)], 20), AuxiliaryVector([(11, 1)], 20), AuxiliaryVector([(13, 1)], 20), AuxiliaryVector([(14, 1)], 20), AuxiliaryVector([(10, 1), (11, 1)], 20), AuxiliaryVector([(11, 2)], 20), AuxiliaryVector([(10, 1), (11, 2)], 20), AuxiliaryVector([(11, 3)], 20), AuxiliaryVector([(11, 4)], 20), ] hier_stable = [ AuxiliaryVector([], 20), AuxiliaryVector([(9, 1)], 20), AuxiliaryVector([(10, 1)], 20), AuxiliaryVector([(11, 1)], 20), AuxiliaryVector([(10, 1), (11, 1)], 20), AuxiliaryVector([(11, 2)], 20), AuxiliaryVector([(10, 1), (11, 2)], 20), AuxiliaryVector([(11, 3)], 20), AuxiliaryVector([(11, 4)], 20), ] hier_bound = [ AuxiliaryVector([(5, 1)], 20), AuxiliaryVector([(13, 1)], 20), AuxiliaryVector([(14, 1)], 20), ] hier_update = (hier_new, hier_stable, hier_bound) phi, _ = hops_ad.basis.update_basis(hops_ad.phi, state_update, hier_update) P2 = hops_ad.phi.view().reshape([3, 9], order="F") P2_new = phi.view().reshape([hops_ad.n_state, hops_ad.n_hier], order="F") assert np.shape(P2) == np.shape(np.zeros((3, 9))) assert np.shape(P2_new) == np.shape(np.zeros((5, 12))) assert P2[1, 5] == P2_new[2, 8] assert P2[1, 1] == P2_new[2, 2] assert P2[1, 7] == P2_new[2, 10] assert P2[2, 3] == P2_new[3, 4]
def test_inchworm_state(): """ test to check inchworm is contributing to the state list """ noise_param = { "SEED": 0, "MODEL": "FFT_FILTER", "TLEN": 250.0, # Units: fs "TAU": 1.0, # Units: fs } nsite = 10 e_lambda = 20.0 gamma = 50.0 temp = 140.0 (g_0, w_0) = bcf_convert_sdl_to_exp(e_lambda, gamma, 0.0, temp) loperator = np.zeros([10, 10, 10], dtype=np.float64) gw_sysbath = [] lop_list = [] for i in range(nsite): loperator[i, i, i] = 1.0 gw_sysbath.append([g_0, w_0]) lop_list.append(sp.sparse.coo_matrix(loperator[i])) gw_sysbath.append([-1j * np.imag(g_0), 500.0]) lop_list.append(loperator[i]) hs = np.zeros([nsite, nsite]) hs[0, 1] = 40 hs[1, 0] = 40 hs[1, 2] = 10 hs[2, 1] = 10 hs[2, 3] = 40 hs[3, 2] = 40 hs[3, 4] = 10 hs[4, 3] = 10 hs[4, 5] = 40 hs[5, 4] = 40 hs[5, 6] = 10 hs[6, 5] = 10 hs[6, 7] = 40 hs[7, 6] = 40 hs[7, 8] = 10 hs[8, 7] = 10 hs[8, 9] = 40 hs[9, 8] = 40 sys_param = { "HAMILTONIAN": np.array(hs, dtype=np.complex128), "GW_SYSBATH": gw_sysbath, "L_HIER": lop_list, "L_NOISE1": lop_list, "ALPHA_NOISE1": bcf_exp, "PARAM_NOISE1": gw_sysbath, } eom_param = {"EQUATION_OF_MOTION": "NORMALIZED NONLINEAR"} integrator_param = { "INTEGRATOR": "RUNGE_KUTTA", "INCHWORM": True, "INCHWORM_MIN": 5, } psi_0 = np.array([0.0] * nsite, dtype=np.complex) psi_0[2] = 1.0 psi_0 = psi_0 / np.linalg.norm(psi_0) hops_inchworm = HOPS( sys_param, noise_param=noise_param, hierarchy_param={"MAXHIER": 2}, eom_param=eom_param, integration_param=integrator_param, ) hops_inchworm.make_adaptive(1e-15, 1e-15) hops_inchworm.initialize(psi_0) state_list = hops_inchworm.state_list known_state_list = [1, 2, 3] assert tuple(state_list) == tuple(known_state_list) z_step = hops_inchworm._prepare_zstep(2.0, hops_inchworm.storage.z_mem) (state_update, aux_update) = hops_inchworm.basis.define_basis(hops_inchworm.phi, 2.0, z_step) # First inchworm step # ---------------------------------------------------------------------------------- state_update, aux_update, phi = hops_inchworm.inchworm_integrate( state_update, aux_update, 2.0) state_new = state_update[0] known = [0, 1, 2, 3, 4] assert np.array_equal(state_new, known) state_stable = state_update[1] known = [1, 2, 3] assert np.array_equal(state_stable, known) add_state = state_update[2] known = [0, 4] assert np.array_equal(add_state, known) # Second inchworm step # ---------------------------------------------------------------------------------- state_update, aux_update, phi = hops_inchworm.inchworm_integrate( state_update, aux_update, 2.0) state_new = state_update[0] known = [0, 1, 2, 3, 4, 5] assert np.array_equal(state_new, known) state_stable = state_update[1] known = [0, 1, 2, 3, 4] assert np.array_equal(state_stable, known) add_state = state_update[2] known = [5] assert np.array_equal(add_state, known) # Third inchworm step # ---------------------------------------------------------------------------------- state_update, aux_update, phi = hops_inchworm.inchworm_integrate( state_update, aux_update, 2.0) state_new = state_update[0] known = [0, 1, 2, 3, 4, 5, 6] assert np.array_equal(state_new, known) state_stable = state_update[1] known = [0, 1, 2, 3, 4, 5] assert np.array_equal(state_stable, known) add_state = state_update[2] known = [6] assert np.array_equal(add_state, known)
def test_check_hierarchy_list(): """ Test to make sure check_state_list is giving out correct stable and bound hierarchy members """ noise_param = { "SEED": 0, "MODEL": "FFT_FILTER", "TLEN": 250.0, # Units: fs "TAU": 1.0, # Units: fs } nsite = 2 e_lambda = 20.0 gamma = 50.0 temp = 140.0 (g_0, w_0) = bcf_convert_sdl_to_exp(e_lambda, gamma, 0.0, temp) loperator = np.zeros([2, 2, 2], dtype=np.float64) gw_sysbath = [] lop_list = [] for i in range(nsite): loperator[i, i, i] = 1.0 gw_sysbath.append([g_0, w_0]) lop_list.append(sp.sparse.coo_matrix(loperator[i])) gw_sysbath.append([-1j * np.imag(g_0), 500.0]) lop_list.append(loperator[i]) hs = np.zeros([nsite, nsite], dtype=np.float64) hs[0, 1] = 40 hs[1, 0] = 40 sys_param = { "HAMILTONIAN": np.array(hs, dtype=np.complex128), "GW_SYSBATH": gw_sysbath, "L_HIER": lop_list, "L_NOISE1": lop_list, "ALPHA_NOISE1": bcf_exp, "PARAM_NOISE1": gw_sysbath, } eom_param = {"EQUATION_OF_MOTION": "NORMALIZED NONLINEAR"} integrator_param = { "INTEGRATOR": "RUNGE_KUTTA", "INCHWORM": False, "INCHWORM_MIN": 5, } psi_0 = np.array([0.0] * nsite, dtype=np.complex) psi_0[1] = 1.0 psi_0 = psi_0 / np.linalg.norm(psi_0) hops_ad = HOPS( sys_param, noise_param=noise_param, hierarchy_param={"MAXHIER": 4}, eom_param=eom_param, integration_param=integrator_param, ) hops_ad.make_adaptive(1e-3, 1e-3) hops_ad.initialize(psi_0) # inital hierarchy z_step = [0, 0] list_aux_stable, list_aux_boundary = hops_ad.basis._check_hierarchy_list( hops_ad.phi, 2.0, z_step ) known_stable = [ AuxiliaryVector([], 4), AuxiliaryVector([(2, 1)], 4), AuxiliaryVector([(3, 1)], 4), ] assert np.array_equal(list_aux_stable, known_stable) known_boundary = [] assert tuple(known_boundary) == tuple(list_aux_boundary) # hierarchy after propagate hops_ad.propagate(12.0, 2.0) list_aux_stable, list_aux_boundary = hops_ad.basis._check_hierarchy_list( hops_ad.phi, 2.0, z_step ) known_stable = [ AuxiliaryVector([], 4), AuxiliaryVector([(0, 1)], 4), AuxiliaryVector([(1, 1)], 4), AuxiliaryVector([(2, 1)], 4), AuxiliaryVector([(3, 1)], 4), AuxiliaryVector([(0, 1), (1, 1)], 4), AuxiliaryVector([(1, 2)], 4), AuxiliaryVector([(1, 1), (2, 1)], 4), AuxiliaryVector([(1, 1), (3, 1)], 4), AuxiliaryVector([(2, 2)], 4), AuxiliaryVector([(2, 1), (3, 1)], 4), AuxiliaryVector([(3, 2)], 4), AuxiliaryVector([(1, 3)], 4), AuxiliaryVector([(1, 2), (3, 1)], 4), AuxiliaryVector([(1, 1), (3, 2)], 4), AuxiliaryVector([(2, 2), (3, 1)], 4), AuxiliaryVector([(2, 1), (3, 2)], 4), AuxiliaryVector([(3, 3)], 4), AuxiliaryVector([(1, 4)], 4), AuxiliaryVector([(1, 3), (3, 1)], 4), AuxiliaryVector([(2, 2), (3, 2)], 4), AuxiliaryVector([(2, 1), (3, 3)], 4), AuxiliaryVector([(3, 4)], 4), ] assert list_aux_stable == known_stable known_boundary = [ AuxiliaryVector([(1, 1), (3, 3)], 4), AuxiliaryVector([(1, 2), (3, 2)], 4), ] assert list_aux_boundary == known_boundary
def test_error_sflux_state(): """ test for the error associated with flux out of each state in S_0 """ noise_param = { "SEED": 0, "MODEL": "FFT_FILTER", "TLEN": 250.0, # Units: fs "TAU": 1.0, # Units: fs } nsite = 10 e_lambda = 20.0 gamma = 50.0 temp = 140.0 (g_0, w_0) = bcf_convert_sdl_to_exp(e_lambda, gamma, 0.0, temp) loperator = np.zeros([10, 10, 10], dtype=np.float64) gw_sysbath = [] lop_list = [] for i in range(nsite): loperator[i, i, i] = 1.0 gw_sysbath.append([g_0, w_0]) lop_list.append(sp.sparse.coo_matrix(loperator[i])) gw_sysbath.append([-1j * np.imag(g_0), 500.0]) lop_list.append(loperator[i]) hs = np.zeros([nsite, nsite]) hs[0, 1] = 40 hs[1, 0] = 40 hs[1, 2] = 10 hs[2, 1] = 10 hs[2, 3] = 40 hs[3, 2] = 40 hs[3, 4] = 10 hs[4, 3] = 10 hs[4, 5] = 40 hs[5, 4] = 40 hs[5, 6] = 10 hs[6, 5] = 10 hs[6, 7] = 40 hs[7, 6] = 40 hs[7, 8] = 10 hs[8, 7] = 10 hs[8, 9] = 40 hs[9, 8] = 40 sys_param = { "HAMILTONIAN": np.array(hs, dtype=np.complex128), "GW_SYSBATH": gw_sysbath, "L_HIER": lop_list, "L_NOISE1": lop_list, "ALPHA_NOISE1": bcf_exp, "PARAM_NOISE1": gw_sysbath, } eom_param = {"EQUATION_OF_MOTION": "NORMALIZED NONLINEAR"} integrator_param = { "INTEGRATOR": "RUNGE_KUTTA", "INCHWORM": False, "INCHWORM_MIN": 5, } psi_0 = np.array([0.0] * nsite, dtype=np.complex) psi_0[5] = 1.0 psi_0 = psi_0 / np.linalg.norm(psi_0) hops_ad = HOPS( sys_param, noise_param=noise_param, hierarchy_param={"MAXHIER": 2}, eom_param=eom_param, integration_param=integrator_param, ) hops_ad.make_adaptive(1e-3, 1e-3) hops_ad.initialize(psi_0) list_index_aux_stable = [0, 1] list_states = np.arange(10) E1_state_flux = hops_ad.basis.error_sflux_state( hops_ad.phi, list_index_aux_stable, list_states ) known_error = [0.0 + 0.0j, 0.00753443 + 0.0j, 0.0 + 0.0j] assert np.allclose(E1_state_flux, known_error)
def test_determine_basis_from_list(): """ Test to determines the members of a list that must be kept in order for the total error to be below the max_error value. """ noise_param = { "SEED": 0, "MODEL": "FFT_FILTER", "TLEN": 250.0, # Units: fs "TAU": 1.0, # Units: fs } nsite = 10 e_lambda = 20.0 gamma = 50.0 temp = 140.0 (g_0, w_0) = bcf_convert_sdl_to_exp(e_lambda, gamma, 0.0, temp) loperator = np.zeros([10, 10, 10], dtype=np.float64) gw_sysbath = [] lop_list = [] for i in range(nsite): loperator[i, i, i] = 1.0 gw_sysbath.append([g_0, w_0]) lop_list.append(sp.sparse.coo_matrix(loperator[i])) gw_sysbath.append([-1j * np.imag(g_0), 500.0]) lop_list.append(loperator[i]) hs = np.zeros([nsite, nsite]) hs[0, 1] = 40 hs[1, 0] = 40 hs[1, 2] = 10 hs[2, 1] = 10 hs[2, 3] = 40 hs[3, 2] = 40 hs[3, 4] = 10 hs[4, 3] = 10 hs[4, 5] = 40 hs[5, 4] = 40 hs[5, 6] = 10 hs[6, 5] = 10 hs[6, 7] = 40 hs[7, 6] = 40 hs[7, 8] = 10 hs[8, 7] = 10 hs[8, 9] = 40 hs[9, 8] = 40 sys_param = { "HAMILTONIAN": np.array(hs, dtype=np.complex128), "GW_SYSBATH": gw_sysbath, "L_HIER": lop_list, "L_NOISE1": lop_list, "ALPHA_NOISE1": bcf_exp, "PARAM_NOISE1": gw_sysbath, } eom_param = {"EQUATION_OF_MOTION": "NORMALIZED NONLINEAR"} integrator_param = { "INTEGRATOR": "RUNGE_KUTTA", "INCHWORM": False, "INCHWORM_MIN": 5, } psi_0 = np.array([0.0] * nsite, dtype=np.complex) psi_0[5] = 1.0 psi_0 = psi_0 / np.linalg.norm(psi_0) hops_ad = HOPS( sys_param, noise_param=noise_param, hierarchy_param={"MAXHIER": 2}, eom_param=eom_param, integration_param=integrator_param, ) hops_ad.make_adaptive(1e-3, 1e-3) hops_ad.initialize(psi_0) # sorted list error_by_member = np.array([0.1, 0.1, 0.3, 0.2, 0.3]) max_error = 0.2 list_member = np.array([1, 2, 3, 4, 5]) list_index, list_new_member = hops_ad.basis._determine_basis_from_list( error_by_member, max_error, list_member ) known_index = [2, 3, 4] assert np.array_equal(list_index, known_index) known_members = [3, 4, 5] assert np.array_equal(list_new_member, known_members) # unsorted list error_by_member = np.array([0.2, 0.4, 0.1, 0.3, 0.2]) max_error = 0.3 list_member = np.array([1, 2, 3, 4, 5]) list_index, list_new_member = hops_ad.basis._determine_basis_from_list( error_by_member, max_error, list_member ) known_index = [1, 3] assert np.array_equal(list_index, known_index) known_members = [2, 4] assert np.array_equal(list_new_member, known_members)
def test_define_basis_state(): """ Test to check whether the correct state basis is being calculated """ noise_param = { "SEED": 0, "MODEL": "FFT_FILTER", "TLEN": 250.0, # Units: fs "TAU": 1.0, # Units: fs } nsite = 10 e_lambda = 20.0 gamma = 50.0 temp = 140.0 (g_0, w_0) = bcf_convert_sdl_to_exp(e_lambda, gamma, 0.0, temp) loperator = np.zeros([10, 10, 10], dtype=np.float64) gw_sysbath = [] lop_list = [] for i in range(nsite): loperator[i, i, i] = 1.0 gw_sysbath.append([g_0, w_0]) lop_list.append(sp.sparse.coo_matrix(loperator[i])) gw_sysbath.append([-1j * np.imag(g_0), 500.0]) lop_list.append(loperator[i]) hs = np.zeros([nsite, nsite]) hs[0, 1] = 40 hs[1, 0] = 40 hs[1, 2] = 10 hs[2, 1] = 10 hs[2, 3] = 40 hs[3, 2] = 40 hs[3, 4] = 10 hs[4, 3] = 10 hs[4, 5] = 40 hs[5, 4] = 40 hs[5, 6] = 10 hs[6, 5] = 10 hs[6, 7] = 40 hs[7, 6] = 40 hs[7, 8] = 10 hs[8, 7] = 10 hs[8, 9] = 40 hs[9, 8] = 40 sys_param = { "HAMILTONIAN": np.array(hs, dtype=np.complex128), "GW_SYSBATH": gw_sysbath, "L_HIER": lop_list, "L_NOISE1": lop_list, "ALPHA_NOISE1": bcf_exp, "PARAM_NOISE1": gw_sysbath, } eom_param = {"EQUATION_OF_MOTION": "NORMALIZED NONLINEAR"} integrator_param = { "INTEGRATOR": "RUNGE_KUTTA", "INCHWORM": False, "INCHWORM_MIN": 5, } psi_0 = np.array([0.0] * nsite, dtype=np.complex) psi_0[5] = 1.0 psi_0 = psi_0 / np.linalg.norm(psi_0) hops_ad = HOPS( sys_param, noise_param=noise_param, hierarchy_param={"MAXHIER": 2}, eom_param=eom_param, integration_param=integrator_param, ) hops_ad.make_adaptive(1e-3, 1e-3) hops_ad.initialize(psi_0) z_step = np.zeros(10) state_update, _ = hops_ad.basis.define_basis(hops_ad.phi, 2.0, z_step) # initial state state_new, state_stable, state_bound = state_update known_new = [4, 5, 6] assert state_new == known_new known_stable = [4, 5, 6] assert tuple(state_stable) == tuple(known_stable) known_bound = [] assert np.array_equal(state_bound, known_bound) # state after propagation hops_ad.propagate(10, 2) state_update, _ = hops_ad.basis.define_basis(hops_ad.phi, 2.0, z_step) state_new, state_stable, state_bound = state_update known_new = [3, 4, 5, 6, 7] assert state_new == known_new known_stable = [4, 5, 6] assert tuple(state_stable) == tuple(known_stable) known_bound = [3, 7] assert np.array_equal(state_bound, known_bound)
"PARAM_NOISE1": gw_sysbath, } eom_param = {"EQUATION_OF_MOTION": "NORMALIZED NONLINEAR"} integrator_param = {"INTEGRATOR": "RUNGE_KUTTA"} psi_0 = np.array([0.0] * nsite, dtype=np.complex) psi_0[2] = 1.0 psi_0 = psi_0 / np.linalg.norm(psi_0) t_max = 200.0 t_step = 4.0 hops = HOPS( sys_param, noise_param=noise_param, hierarchy_param={"MAXHIER": 2}, eom_param=eom_param, ) hops.initialize(psi_0) # Saved Data # ---------- path_data = os.path.realpath(__file__) path_data = path_data[:-len("test_dimer_of_dimers.py")] + "/dimer_of_dimers" def construct_permute_matrix(stable_aux, stable_state, hops): n_reduced = len(stable_aux) * len(stable_state) n_full = hops.n_hier * hops.n_state permute_aux_row = []
def test_error_sflux_hier(): """ test for the error introduced by losing flux within k from S_0 to S_0^C for each k in H_0 """ noise_param = { "SEED": 0, "MODEL": "FFT_FILTER", "TLEN": 250.0, # Units: fs "TAU": 1.0, # Units: fs } nsite = 10 e_lambda = 20.0 gamma = 50.0 temp = 140.0 (g_0, w_0) = bcf_convert_sdl_to_exp(e_lambda, gamma, 0.0, temp) loperator = np.zeros([10, 10, 10], dtype=np.float64) gw_sysbath = [] lop_list = [] for i in range(nsite): loperator[i, i, i] = 1.0 gw_sysbath.append([g_0, w_0]) lop_list.append(sp.sparse.coo_matrix(loperator[i])) gw_sysbath.append([-1j * np.imag(g_0), 500.0]) lop_list.append(loperator[i]) hs = np.zeros([nsite, nsite]) hs[0, 1] = 40 hs[1, 0] = 40 hs[1, 2] = 10 hs[2, 1] = 10 hs[2, 3] = 40 hs[3, 2] = 40 hs[3, 4] = 10 hs[4, 3] = 10 hs[4, 5] = 40 hs[5, 4] = 40 hs[5, 6] = 10 hs[6, 5] = 10 hs[6, 7] = 40 hs[7, 6] = 40 hs[7, 8] = 10 hs[8, 7] = 10 hs[8, 9] = 40 hs[9, 8] = 40 sys_param = { "HAMILTONIAN": np.array(hs, dtype=np.complex128), "GW_SYSBATH": gw_sysbath, "L_HIER": lop_list, "L_NOISE1": lop_list, "ALPHA_NOISE1": bcf_exp, "PARAM_NOISE1": gw_sysbath, } eom_param = {"EQUATION_OF_MOTION": "NORMALIZED NONLINEAR"} integrator_param = { "INTEGRATOR": "RUNGE_KUTTA", "INCHWORM": False, "INCHWORM_MIN": 5, } psi_0 = np.array([0.0] * nsite, dtype=np.complex) psi_0[5] = 1.0 psi_0 = psi_0 / np.linalg.norm(psi_0) hops_ad = HOPS( sys_param, noise_param=noise_param, hierarchy_param={"MAXHIER": 2}, eom_param=eom_param, integration_param=integrator_param, ) hops_ad.make_adaptive(1e-3, 1e-3) hops_ad.initialize(psi_0) E2_flux_state = hops_ad.basis.error_sflux_hier(hops_ad.phi, [4, 5, 6]) known_error = [0, 0, 0] assert np.allclose(E2_flux_state, known_error) hops_ad.propagate(10, 2) E2_flux_state = hops_ad.basis.error_sflux_hier(hops_ad.phi, [4, 5, 6]) known_error = [ 4.41017874e-08, 6.25730675e-12, 2.79827656e-09, 8.35537498e-11, 2.83286739e-09, 2.67725191e-09, 5.43756095e-10, 7.32738552e-11, 1.25275631e-13, 1.06073503e-11, 3.93302668e-10, 3.81794277e-10, ] assert np.allclose(E2_flux_state, known_error)
def test_hops_adaptive_dynamics_partial(): """ This is a test of the adaptive dynamics algorithm when threshold is large enough that some states and auxiliaries are missing. """ # Test adaptive hierarchy # ======================= hops_ah = HOPS( sys_param, noise_param=noise_param, hierarchy_param={"MAXHIER": 2}, eom_param=eom_param, ) hops_ah.make_adaptive(1e-3, 0) hops_ah.initialize(psi_0) hops_ah.propagate(t_max, t_step) # Construct permutation for full-->reduced basis # ---------------------------------------------- P2_permute = construct_permute_matrix(hops_ah.auxiliary_list, hops_ah.state_list, hops) # Permute super operators from hops into reduced basis # ---------------------------------------------------- K0 = _permute_aux_by_matrix(hops.basis.eom.K2_k, P2_permute) Kp1 = _permute_aux_by_matrix(hops.basis.eom.K2_kp1, P2_permute) Km1 = _permute_aux_by_matrix(hops.basis.eom.K2_km1, P2_permute) Zp1 = [ _permute_aux_by_matrix(hops.basis.eom.Z2_kp1[index_l2], P2_permute) for index_l2 in hops_ah.basis.system.list_absindex_L2 ] Z0 = [ _permute_aux_by_matrix(hops.basis.eom.Z2_k[index_l2], P2_permute) for index_l2 in hops_ah.basis.system.list_absindex_L2 ] # Compare reduced hops to adhops super operators # ---------------------------------------------- assert (Kp1.todense() == hops_ah.basis.eom.K2_kp1.todense()).all() assert (Km1.todense() == hops_ah.basis.eom.K2_km1.todense()).all() assert (K0.todense() == hops_ah.basis.eom.K2_k.todense()).all() assert np.all([ np.all(Z2_k_hops.todense() == Z2_k_adhops.todense()) for (Z2_k_hops, Z2_k_adhops) in zip(Z0, hops_ah.basis.eom.Z2_k) ]) assert np.all([ np.all(Z2_kp1_hops.todense() == Z2_kp1_adhops.todense()) for (Z2_kp1_hops, Z2_kp1_adhops) in zip(Zp1, hops_ah.basis.eom.Z2_kp1) ]) # Test adaptive system # ==================== hops_ah = HOPS( sys_param, noise_param=noise_param, hierarchy_param={"MAXHIER": 2}, eom_param=eom_param, ) hops_ah.make_adaptive(0, 1e-3) hops_ah.initialize(psi_0) hops_ah.propagate(t_max, t_step) # Construct permutation for full-->reduced basis # ---------------------------------------------- P2_permute = construct_permute_matrix(hops_ah.auxiliary_list, hops_ah.state_list, hops) # Permute super operators from hops into reduced basis # ---------------------------------------------------- K0 = _permute_aux_by_matrix(hops.basis.eom.K2_k, P2_permute) Kp1 = _permute_aux_by_matrix(hops.basis.eom.K2_kp1, P2_permute) Km1 = _permute_aux_by_matrix(hops.basis.eom.K2_km1, P2_permute) Zp1 = [ _permute_aux_by_matrix(hops.basis.eom.Z2_kp1[index_l2], P2_permute) for index_l2 in hops_ah.basis.system.list_absindex_L2 ] Z0 = [ _permute_aux_by_matrix(hops.basis.eom.Z2_k[index_l2], P2_permute) for index_l2 in hops_ah.basis.system.list_absindex_L2 ] # Compare reduced hops to adhops super operators # ---------------------------------------------- assert (Kp1.todense() == hops_ah.basis.eom.K2_kp1.todense()).all() assert (Km1.todense() == hops_ah.basis.eom.K2_km1.todense()).all() assert (K0.todense() == hops_ah.basis.eom.K2_k.todense()).all() assert np.all([ np.all(Z2_k_hops.todense() == Z2_k_adhops.todense()) for (Z2_k_hops, Z2_k_adhops) in zip(Z0, hops_ah.basis.eom.Z2_k) ]) assert np.all([ np.all(Z2_kp1_hops.todense() == Z2_kp1_adhops.todense()) for (Z2_kp1_hops, Z2_kp1_adhops) in zip(Zp1, hops_ah.basis.eom.Z2_kp1) ]) # Test adaptive system and adaptive hierarchy # =========================================== hops_ah = HOPS( sys_param, noise_param=noise_param, hierarchy_param={"MAXHIER": 2}, eom_param=eom_param, ) hops_ah.make_adaptive(1e-3, 1e-3) hops_ah.initialize(psi_0) hops_ah.propagate(t_max, t_step) # Construct permutation for full-->reduced basis # ---------------------------------------------- P2_permute = construct_permute_matrix(hops_ah.auxiliary_list, hops_ah.state_list, hops) # Permute super operators from hops into reduced basis # ---------------------------------------------------- K0 = _permute_aux_by_matrix(hops.basis.eom.K2_k, P2_permute) Kp1 = _permute_aux_by_matrix(hops.basis.eom.K2_kp1, P2_permute) Km1 = _permute_aux_by_matrix(hops.basis.eom.K2_km1, P2_permute) Zp1 = [ _permute_aux_by_matrix(hops.basis.eom.Z2_kp1[index_l2], P2_permute) for index_l2 in hops_ah.basis.system.list_absindex_L2 ] Z0 = [ _permute_aux_by_matrix(hops.basis.eom.Z2_k[index_l2], P2_permute) for index_l2 in hops_ah.basis.system.list_absindex_L2 ] # Compare reduced hops to adhops super operators # ---------------------------------------------- assert (Kp1.todense() == hops_ah.basis.eom.K2_kp1.todense()).all() assert (Km1.todense() == hops_ah.basis.eom.K2_km1.todense()).all() assert (K0.todense() == hops_ah.basis.eom.K2_k.todense()).all() assert np.all([ np.all(Z2_k_hops.todense() == Z2_k_adhops.todense()) for (Z2_k_hops, Z2_k_adhops) in zip(Z0, hops_ah.basis.eom.Z2_k) ]) assert np.all([ np.all(Z2_kp1_hops.todense() == Z2_kp1_adhops.todense()) for (Z2_kp1_hops, Z2_kp1_adhops) in zip(Zp1, hops_ah.basis.eom.Z2_kp1) ])
def test_error_sflux_hier(): """ test for the error introduced by losing flux within k from S_0 to S_0^C for each k in H_0 """ noise_param = { "SEED": 0, "MODEL": "FFT_FILTER", "TLEN": 250.0, # Units: fs "TAU": 1.0, # Units: fs } nsite = 10 e_lambda = 20.0 gamma = 50.0 temp = 140.0 (g_0, w_0) = bcf_convert_sdl_to_exp(e_lambda, gamma, 0.0, temp) loperator = np.zeros([10, 10, 10], dtype=np.float64) gw_sysbath = [] lop_list = [] for i in range(nsite): loperator[i, i, i] = 1.0 gw_sysbath.append([g_0, w_0]) lop_list.append(sp.sparse.coo_matrix(loperator[i])) gw_sysbath.append([-1j * np.imag(g_0), 500.0]) lop_list.append(loperator[i]) hs = np.zeros([nsite, nsite]) hs[0, 1] = 40 hs[1, 0] = 40 hs[1, 2] = 10 hs[2, 1] = 10 hs[2, 3] = 40 hs[3, 2] = 40 hs[3, 4] = 10 hs[4, 3] = 10 hs[4, 5] = 40 hs[5, 4] = 40 hs[5, 6] = 10 hs[6, 5] = 10 hs[6, 7] = 40 hs[7, 6] = 40 hs[7, 8] = 10 hs[8, 7] = 10 hs[8, 9] = 40 hs[9, 8] = 40 sys_param = { "HAMILTONIAN": np.array(hs, dtype=np.complex128), "GW_SYSBATH": gw_sysbath, "L_HIER": lop_list, "L_NOISE1": lop_list, "ALPHA_NOISE1": bcf_exp, "PARAM_NOISE1": gw_sysbath, } eom_param = {"EQUATION_OF_MOTION": "NORMALIZED NONLINEAR"} integrator_param = { "INTEGRATOR": "RUNGE_KUTTA", "INCHWORM": False, "INCHWORM_MIN": 5, } psi_0 = np.array([0.0] * nsite, dtype=np.complex) psi_0[5] = 1.0 psi_0 = psi_0 / np.linalg.norm(psi_0) hops_ad = HOPS( sys_param, noise_param=noise_param, hierarchy_param={"MAXHIER": 2}, eom_param=eom_param, integration_param=integrator_param, ) hops_ad.make_adaptive(1e-3, 1e-3) hops_ad.initialize(psi_0) E2_flux_state = hops_ad.basis.error_sflux_hier(hops_ad.phi, [4, 5, 6]) known_error = [0, 0, 0] assert np.allclose(E2_flux_state, known_error) hops_ad.propagate(10, 2) E2_flux_state = hops_ad.basis.error_sflux_hier(hops_ad.phi, [4, 5, 6]) known_error = [ 2.10004255e-04, 2.50146052e-06, 5.28986969e-05, 9.14077348e-06, 5.32245330e-05, 5.17421294e-05, 2.33186603e-05, 8.56003704e-06, 3.53943880e-07, 3.25690823e-06, 1.98318688e-05, 1.95396184e-05 ] assert np.allclose(E2_flux_state, known_error)