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)