def test_filter_aux_list_triangular(): """ This functions checks that the TRIANGULAR filter is being properly applied """ # initializing hops_hierarchy class hierarchy_param = { "MAXHIER": 2, "STATIC_FILTERS": [("Triangular", [[False, True], [1, 1]])], } system_param = {"N_HMODES": 2} HH = HHier(hierarchy_param, system_param) aux_list = [ AuxVec([], 2), AuxVec([(0, 1)], 2), AuxVec([(1, 1)], 2), AuxVec([(0, 2)], 2), AuxVec([(0, 1), (1, 1)], 2), AuxVec([(1, 2)], 2), ] aux_list = HH.filter_aux_list(aux_list) # known result filtered triangular list known_triangular_tuple = [ AuxVec([], 2), AuxVec([(0, 1)], 2), AuxVec([(1, 1)], 2), AuxVec([(0, 2)], 2), ] assert aux_list == known_triangular_tuple assert HH.param["STATIC_FILTERS"] == [("Triangular", [[False, True], [1, 1]])]
def test_define_triangular_hierarchy_4modes_4maxhier(): """ This function test whether define_triangular_hierarchy is properly defining a triangular hierarchy and outputting it to a filtered list """ hierarchy_param = {"MAXHIER": 10} system_param = {"N_HMODES": 10} HH = HHier(hierarchy_param, system_param) assert set(HH.define_triangular_hierarchy(4, 4)) == set(aux_list_4_4) assert set(HH.define_triangular_hierarchy(2, 4)) == set(aux_list_2_4)
def test_const_aux_edge(): """ This function test whether const_aux_edge is properly creating an auxiliary index tuple for an edge node at a particular depth along a given mode. """ hierarchy_param = {"MAXHIER": 4} system_param = {"N_HMODES": 4} HH = HHier(hierarchy_param, system_param) HH.initialize(True) tmp = HH._const_aux_edge(2, 1, 4) known_index_tuple = AuxVec([(2, 1)], 4) assert tmp == known_index_tuple
def test_hierarchy_initialize_true(): """ This test checks whether an adaptive calculation (True) creates a list of tuples n_hmodes long """ # initializing hops_hierarchy class hierarchy_param = {"MAXHIER": 4} system_param = {"N_HMODES": 4} HH = HHier(hierarchy_param, system_param) HH.initialize(True) # makes the calculation adaptive aux_list = HH.auxiliary_list known_tuple = [AuxVec([], 4)] assert known_tuple == aux_list
def test_aux_index_true(): """ This function test the case where _aux_index returns the absolute index of a specific auxiliary member """ hierarchy_param = {"MAXHIER": 4} system_param = {"N_HMODES": 4} HH = HHier(hierarchy_param, system_param) abs_index = HH._aux_index( AuxVec([(0, 1), (2, 1)], 4), True ) # True = absolute index # known result based on alpha numeric ordering known_index = 7 assert abs_index == known_index
def test_hierarchy_initialize_false(): """ This test checks whether a non-adaptive calculation (False) creates a list of tuples applied to a triangular filter """ # initializing hops_hierarchy class hierarchy_param = {"MAXHIER": 2, "STATIC_FILTERS": []} system_param = {"N_HMODES": 2} HH = HHier(hierarchy_param, system_param) HH.initialize(False) aux_list = HH.auxiliary_list # known result triangular filtered list known_triangular_list = [ AuxVec([], 2), AuxVec([(0, 1)], 2), AuxVec([(1, 1)], 2), AuxVec([(0, 2)], 2), AuxVec([(0, 1), (1, 1)], 2), AuxVec([(1, 2)], 2), ] assert known_triangular_list == aux_list
def test_aux_index_false(): """ This function test the case where _aux_index returns the relative index of a specific auxiliary member. It is important to note because of auxilary_list setter our auxiliary list gets rearranged into alpha numerical order and the return index is that of the relative list in alpha numerical order """ hierarchy_param = {"MAXHIER": 4} system_param = {"N_HMODES": 4} HH = HHier(hierarchy_param, system_param) HH.auxiliary_list = [ AuxVec([], 4), AuxVec([(2, 1), (3, 1)], 4), AuxVec([(0, 1), (1, 1)], 4), AuxVec([(0, 1), (2, 1)], 4), AuxVec([(1, 1), (3, 1)], 4), ] relative_index = HH._aux_index(AuxVec([(0, 1), (2, 1)], 4), False) # known result based on alpha numerical ordering known_index = 2 assert relative_index == known_index
def test_filer_aux_list_longedge(): hierarchy_param = {"MAXHIER": 2} system_param = {"N_HMODES": 2} HH = HHier(hierarchy_param, system_param) aux_list = [ AuxVec([], 2), AuxVec([(0, 1)], 2), AuxVec([(1, 1)], 2), AuxVec([(0, 2)], 2), AuxVec([(0, 1), (1, 1)], 2), AuxVec([(1, 2)], 2), ] known_aux_list = [ AuxVec([], 2), AuxVec([(0, 1)], 2), AuxVec([(1, 1)], 2), AuxVec([(0, 2)], 2), AuxVec([(1, 2)], 2), ] aux_list = HH.apply_filter(aux_list, "LongEdge", [[False, True], [2, 1]]) assert aux_list == known_aux_list assert HH.param["STATIC_FILTERS"] == [("LongEdge", [[False, True], [2, 1]])]
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)