def test_construct_hamiltonian(self):
N = self.N
# 1D, 2 level
cell = [[0, 1]]
f = [lambda x: 2 * x] * 4
potential = Potential(cell, f=f, n=2)
self.grid1d2n.construct_V_matrix(potential)
test.assert_equal(self.grid1d2n.V.shape, (2 * N, 2 * N))
# 2D, 2 level
cell = [[0, 1], [0, 1]]
f = [lambda x, y: 2 * x + 2 * y] * 4
potential = Potential(cell, f=f, n=2)
self.grid2d2n.construct_hamiltonian(potential)
test.assert_equal(self.grid2d2n.H.shape, (2 * N**2, 2 * N**2))
# 1D, 1 level
cell = [[0, 1]]
f = [lambda x: 2 * x]
potential = Potential(cell, f=f, n=1)
self.grid1d1n.construct_hamiltonian(potential)
test.assert_equal(self.grid1d1n.H.shape, (N, N))
# 2D, 1 level
cell = [[0, 1], [0, 1]]
f = [lambda x, y: 2 * x + 2 * y]
potential = Potential(cell, f=f, n=1)
self.grid2d1n.construct_hamiltonian(potential)
test.assert_equal(self.grid2d1n.H.shape, (N**2, N**2))
def __init__(self, cell=[[-10, 10]], a=0.0006, b=0.10, c=0.90):
self.A = a
self.B = b
self.C = c
f = self.get_f()
firstd = self.get_deriv()
Potential.__init__(self, cell=cell, n=2, f=f, firstd=firstd)
def __init__(self, cell=[[-10, 10]], a=0.01, b=1.6, c=0.005, d=1.0):
self.A = a
self.B = b
self.C = c
self.D = d
f = self.get_f()
firstd = self.get_deriv()
Potential.__init__(self, cell=cell, n=2, f=f, firstd=firstd)
def setUp(self):
# 2D testing
# cell = [[0, 20], [0, 20]]
# coords = [[1, 4]]
# velocities = [[0, 0]]
# masses = [1860]
# 1D testing
cell = [[0, 20]]
coords = [[10]]
velocities = [[0]]
masses = [1860]
n_beads = 4
self.T = 3000
self.beta = 1 / (self.T * n_beads)
n_states = 2
self.system = MF_RPMD(coords,
velocities,
masses,
n_beads=n_beads,
T=self.T,
n_states=n_states)
def f(a):
return 0.00002 * a
def f2(a):
return -0.00002 * a
def off(a):
return np.full_like(a, -0.1)
self.potential = Potential(cell, f=[f, off, off, f2], n=2)
def setUp(self):
# 2D testing
# cell = [[0, 20], [0, 20]]
# coords = [[1, 4]]
# velocities = [[0, 0]]
# masses = [1860]
# 1D testing
cell = [[0, 20]]
coords = [[10]]
velocities = [[0]]
masses = [1860]
n_beads = 4
T = 300
self.initial_state = 1
n_states = 2
self.system = NRPMD(coords, velocities, masses, n_beads=n_beads, T=T,
initial_state=self.initial_state, n_states=n_states, seed=10)
# def f(a, b):
# return a * b
# def f2(a, b):
# return 2 * a * b
# def off(a, b):
# return 0.1 * a
def f(a):
return 2*a
def f2(a):
return -2*a
def off(a):
return np.full_like(a, -0.1)
self.potential = Potential(cell, f=[f, off, off, f2], n=2)
def update_potential(self, attr, old, new):
self.f = eval('preset_potentials.' + self.choose.value +
f'({self.settings.ndim})')
self.potential = Potential(self.settings.cell, f=self.f())
x = np.linspace(self.settings.cell[0][0], self.settings.cell[0][1],
100)
y = self.potential(x)
self.source.data = dict(x=x, y=y)
def __init__(self,
cell=[[-10, 10]],
a=0.1,
b=0.28,
c=0.015,
d=0.06,
e=0.05):
self.A = a
self.B = b
self.C = c
self.D = d
self.E_0 = e
f = self.get_f()
firstd = self.get_deriv()
Potential.__init__(self, cell=cell, n=2, f=f, firstd=firstd)
def setUp(self):
cell = [[-5, 5], [-5, 5]]
coords = [[0, 0], [3, 3], [3, 7]]
velocities = [[1, 1], [-1, 2], [0, 0]]
masses = [1, 2, 1]
self.phasespace = PhaseSpace(coords, velocities, masses)
def f(a, b):
return a * b
self.potential = Potential(cell, f=f)
def setUp(self):
cell = [[0, 20], [0, 20]]
coords = [[1, 1], [2, 2]]
velocities = [[0, 0], [1, 1]]
masses = [1860, 100]
n_beads = 4
T = 293.15
self.rpmd = RPMD(coords, velocities, masses, n_beads, T)
# self.rpmd = RPMD(coords, velocities, masses, n_beads, T,
# init_type='position')
def f(a, b):
return a * b
self.potential = Potential(cell, f=f)