def one_step(self, q_list0, p_list0, l_list):
# update p0 -> p1
p_input0 = self.force_function.prepare_p_input(q_list0, p_list0,
l_list)
q_input0 = self.force_function.prepare_q_input(0, q_list0, p_list0,
l_list)
p_input_list = [p_input0]
q_input_list = [q_input0]
p_list1 = p_list0 + self.force_function.eval(q_input_list,
p_input_list)
# update q0 -> q1
p_input1 = self.force_function.prepare_p_input(
q_list0, p_list1,
l_list) ##### note, use q_list0 instead of q_list1
p_input_list.append(p_input1)
q_list1 = q_list0 + self.force_function.eval(q_input_list,
p_input_list)
#q_list1.retain_grad()
q_list1 = pbc(q_list1, l_list)
# update p1 -> p2
q_input1 = self.force_function.prepare_q_input(1, q_list1, p_list1,
l_list)
q_input_list.append(q_input1)
p_list2 = p_list1 + self.force_function.eval(q_input_list,
p_input_list)
# update q1 -> q2
p_input2 = self.force_function.prepare_p_input(
q_list1, p_list2,
l_list) ##### note, use q_list1 instead of q_list2
p_input_list.append(p_input2)
q_list2 = q_list1 + self.force_function.eval(q_input_list,
p_input_list)
#q_list2.retain_grad()
q_list2 = pbc(q_list2, l_list)
# update p2 -> p3
q_input2 = self.force_function.prepare_q_input(2, q_list2, p_list2,
l_list)
q_input_list.append(q_input2)
p_list3 = p_list2 + self.force_function.eval(q_input_list,
p_input_list)
# update q2 -> q3
p_input3 = self.force_function.prepare_p_input(
q_list2, p_list3,
l_list) ##### note, use q_list2 instead of q_list3
p_input_list.append(p_input3)
q_list3 = q_list2 + self.force_function.eval(q_input_list,
p_input_list)
#q_list3.retain_grad()
q_list3 = pbc(q_list3, l_list)
assert_nan(p_list3)
assert_nan(q_list3)
return q_list3, p_list3, l_list
def del_q_adjust(self, q_quantity, q_label, l_list):
dq = q_quantity - q_label
# shape [nsamples, nparticle, DIM]
pbc(dq, l_list)
return dq
def euler(q, p, l):
dt = 1e-3
for t in range(100):
a = q.clone().detach() # ideal gas
q = q + dt * p # move in striaght line
pbc(q, l)
p = p + dt * a # acceleration
return q, p
def dpair_pbc_sq(self, q, u_list, l_list): #
# all list dimensionless
q_state = torch.unsqueeze(q, dim=2)
# shape is [nsamples, nparticles, 1, DIM=(x,y)]
u_list = torch.unsqueeze(u_list, dim=1)
# shape is [nsamples, 1, nparticles* ngrids, DIM=(x,y)]
paired_grid_q = u_list - q_state
# paired_grid_q.shape is [nsamples, nparticles, nparticles * ngrids, DIM]
pbc(paired_grid_q, l_list)
dd = torch.sum(paired_grid_q * paired_grid_q, dim=-1)
# dd.shape is [nsamples, nparticles, nparticles * ngrids]
return paired_grid_q, dd
def one_step(self,q_list,p_list,l_list,tau):
p_list_1 = p_list + 0.5*tau*self.force_function.eval1(q_list,p_list,l_list,tau)
q_list_1 = q_list + 0.5*tau*self.momentum_function.eval1(q_list,p_list_1,l_list,tau)
q_list_1.retain_grad()
q_list_1 = pbc(q_list_1,l_list)
q_list_2 = q_list_1 + 0.5*tau*self.momentum_function.eval2(q_list_1,p_list_1,l_list,tau)
q_list_2.retain_grad()
q_list_2 = pbc(q_list_2,l_list)
p_list_2 = p_list_1 + 0.5*tau*self.force_function.eval2(q_list_2,p_list_1,l_list,tau)
assert_nan(p_list_2)
assert_nan(q_list_2)
return q_list_2,p_list_2,l_list
def make_grids_center(self,q, l_list,b):
'''make_grids function to shift 6 grids points at (0,0) to each particle position as center'''
l_list = torch.unsqueeze(l_list, dim=2)
# boxsize.shape is [nsamples, nparticle, 1, DIM]
l_list = l_list.repeat_interleave(self.hex_grids_list(b).shape[0], dim=2)
q_list = torch.unsqueeze(q, dim=2)
# q_list.shape is [nsamples, nparticle, 1, DIM=(x coord, y coord)]
grids_ncenter = self.hex_grids_list(b) + q_list
# grids_ncenter.shape is [6, 2] + [nsamples, nparticle, 1, DIM] => [nsample, nparticle, 6, DIM=2]
pbc(grids_ncenter, l_list) # pbc - for grids
#self.show_grids_nparticles(q, grids_ncenter,l_list[0,0,0])
grids_ncenter = grids_ncenter.view(-1, q.shape[1] * self.hex_grids_list(b).shape[0], q.shape[2])
# shape is [nsamples, nparticle*ngrids, DIM=(x,y)]
return grids_ncenter
def one_step(self,q_list,p_list,l_list,tau):
#f1 = self.force_function.eval1(q_list,p_list,l_list,tau)
p_list_2 = p_list + 0.5*tau*self.force_function.eval1(q_list,p_list,l_list,tau)
q_list_2 = q_list + tau*p_list_2
q_list_2.retain_grad()
q_list_new = pbc(q_list_2,l_list)
p_list_new = p_list_2 + 0.5*tau*self.force_function.eval2(q_list_new,p_list_2,l_list,tau)
#f2 = self.force_function.eval2(q_list_new,p_list_2,l_list,tau)
assert_nan(p_list_new)
assert_nan(q_list_new)
return q_list_new,p_list_new,l_list
def one_step(self, q_list0, p_list0, l_list):
p_input0 = self.force_function.prepare_p_input(q_list0, p_list0,
l_list)
q_input0 = self.force_function.prepare_q_input(0, q_list0, p_list0,
l_list)
p_input_list = [p_input0]
q_input_list = [q_input0]
p_list_pre = p_list0
q_list_pre = q_list0
for s in range(velocity_verletx.neval):
p_list_cur = p_list_pre + self.force_function.eval(
q_input_list, p_input_list)
p_input_next = self.force_function.prepare_p_input(
q_list_pre, p_list_cur, l_list)
p_input_list.append(p_input_next)
tau = self.force_function.get_tau(2 * s + 1)
q_list_cur = q_list_pre + tau * p_list_cur + self.force_function.eval(
q_input_list, p_input_list)
#q_list_cur = q_list_pre + self.force_function.eval(q_input_list,p_input_list)
q_list_cur = pbc(q_list_cur, l_list)
net_idx = s
q_input_next = self.force_function.prepare_q_input(
net_idx, q_list_cur, p_list_cur, l_list)
q_input_list.append(q_input_next)
p_list_pre = p_list_cur
q_list_pre = q_list_cur
assert_nan(p_list_cur)
assert_nan(q_list_cur)
return q_list_cur, p_list_cur, l_list