def step(self):
# select the transfered atom
ind = randint(0,self.nmol_tot)
if ind >= self.nmol:
self.count_qm += 1
x_mol_save = copy(self.mol_qm.get_positions())
#print euler_rotation(*self.delta_mol) * x_mol_save.T
alpha, beta, gamma = self.delta_qm[1] * random_v(3)
alpha *= pi; beta *= pi * 0.5; gamma *= pi
x_mol_try = (euler_rotation(alpha, beta, gamma) * x_mol_save.T).T
x_mol_try += self.delta_qm[0]*random_v(self.mol.get_ndims())
self.mol_qm.set_positions(x_mol_try)
ene_qmmm_pre = np.sum(self.interaction_qmmm_save)
for i in xrange(len(self.mol)):
self.int_trial_ary[i] = self.pot_qmmm.get_interaction_energy_mc(i)
ene_qmmm_pro = np.sum(self.int_trial_ary)
delta_e = ene_qmmm_pro - ene_qmmm_pre
#print ene_qmmm_pre, ene_qmmm_pro, delta_e
if delta_e < 0.0: judge = True
else:
try: judge = exp(- self.beta * delta_e) > random()
except OverflowError: judge = False
# the trial movement is judged
if judge:
self.count_accept_qm += 1
for i in xrange(len(self.mol)):
self.interaction_qmmm_save[i] = self.int_trial_ary[i]
self.mol_qm.set_potential_energy(ene_qmmm_pro)
self.alpha_save += alpha; self.beta_save += beta; self.gamma_save += gamma
else: self.mol_qm.set_positions(x_mol_save)
else:
self.count_mm += 1
if self.which_frozen[ind]: return
x_save = copy(self.mol.get_positions()[ind])
if self.pot.get_check_pbc():
self.mol.set_positions_index(ind, self.pot.get_pbc_adjusted(x_save \
+ self.delta[ind] * random_v(3)))
else:
self.mol.set_positions_index(ind, x_save \
+ self.delta[ind] * random_v(3))
int_trial = self.pot.get_interaction_energy_mc(ind)
int_trial_qmmm = self.pot_qmmm.get_interaction_energy_mc(ind)
delta_e_mm = np.sum(int_trial) - sum(self.interaction_save[ind])
delta_e_qmmm = int_trial_qmmm - self.interaction_qmmm_save[ind]
delta_e = delta_e_mm + delta_e_qmmm
if delta_e < 0.0: judge = True
else:
try:
judge = exp(- self.beta * delta_e) > random()
except OverflowError: judge = False
# the trial movement is judged
if judge:
self.count_accept_mm += 1
self.interaction_save[ind,:] = int_trial
self.interaction_save[:,ind] = int_trial
self.interaction_qmmm_save[ind] = int_trial_qmmm
self.mol.set_potential_energy(self.mol.get_potential_energy() + delta_e_mm)
self.mol_qm.set_potential_energy(self.mol_qm.get_potential_energy() + delta_e_qmmm)
else: self.mol.set_positions_index(ind, x_save)
def step(self):
# select the transfered atom
ind = randint(0,len(self.mol)-1)
if ind in self.treated_as_molecule:
self.count_tot_mol += 1
x_mol_save = copy(self.mol.get_positions_index(self.treated_as_molecule))
#print euler_rotation(*self.delta_mol) * x_mol_save.T
alpha, beta, gamma = self.delta_mol[1] * random_v(3)
alpha *= pi; beta *= pi * 0.5; gamma *= pi
x_mol_try = (euler_rotation(alpha, beta, gamma) * x_mol_save.T).T
x_mol_try += self.delta_mol[0]*random_v(self.mol.get_ndims())
self.mol.set_positions_index(self.treated_as_molecule, x_mol_try)
int_trial_matrix = np.array([self.pot.get_interaction_energy(i) for i in self.treated_as_molecule])
int_save_matrix = np.array([self.interaction_save[i] for i in self.treated_as_molecule])
delta_e = np.sum(int_trial_matrix) - np.sum(int_save_matrix)
try:
judge = exp(- self.beta * delta_e) > random()
except OverflowError:
if delta_e < 0: judge = True
else: judge = False
# the trial movement is judged
if judge:
self.count_accept_mol += 1
for i in self.treated_as_molecule: self.interaction_save[i,:] = int_trial_matrix[i]
for i in self.treated_as_molecule: self.interaction_save[:,i] = int_trial_matrix[i]
self.mol.set_potential_energy(self.mol.get_potential_energy() + delta_e)
self.alpha_save += alpha; self.beta_save += beta; self.gamma_save += gamma
else: self.mol.set_positions_index(self.treated_as_molecule, x_mol_save)
else:
self.count_tot += 1
if self.which_frozen[ind]: return
x_save = copy(self.mol.get_positions_index(ind))
if self.pot.get_check_pbc():
self.mol.set_positions_index(ind, self.pot.get_pbc_adjusted(x_save \
+ self.delta[ind] * random_v(self.mol.get_ndims())))
else:
self.mol.set_positions_index(ind, x_save \
+ self.delta[ind] * random_v(self.mol.get_ndims()))
int_trial = self.pot.get_interaction_energy(ind)
delta_e = np.sum(int_trial) - np.sum(self.interaction_save[ind])
try:
judge = exp(- self.beta * delta_e) > random()
except OverflowError:
if delta_e < 0: judge = True
else: judge = False
# the trial movement is judged
if judge:
self.count_accept += 1
self.interaction_save[ind,:] = int_trial
self.interaction_save[:,ind] = int_trial
self.mol.set_potential_energy(self.mol.get_potential_energy() + delta_e)
else: self.mol.set_positions_index(ind, x_save)
def step(self):
# select the transfered atom
ind = randint(0, self.nmol_tot)
if ind >= self.nmol:
self.count_qm += 1
x_mol_save = copy(self.mol_qm.get_positions())
#print euler_rotation(*self.delta_mol) * x_mol_save.T
alpha, beta, gamma = self.delta_qm[1] * random_v(3)
alpha *= pi
beta *= pi * 0.5
gamma *= pi
x_mol_try = (euler_rotation(alpha, beta, gamma) * x_mol_save.T).T
x_mol_try += self.delta_qm[0] * random_v(self.mol.get_ndims())
self.mol_qm.set_positions(x_mol_try)
ene_qmmm_pre = np.sum(self.interaction_qmmm_save)
for i in xrange(len(self.mol)):
self.int_trial_ary[
i] = self.pot_qmmm.get_interaction_energy_mc(i)
ene_qmmm_pro = np.sum(self.int_trial_ary)
delta_e = ene_qmmm_pro - ene_qmmm_pre
#print ene_qmmm_pre, ene_qmmm_pro, delta_e
if delta_e < 0.0: judge = True
else:
try:
judge = exp(-self.beta * delta_e) > random()
except OverflowError:
judge = False
# the trial movement is judged
if judge:
self.count_accept_qm += 1
for i in xrange(len(self.mol)):
self.interaction_qmmm_save[i] = self.int_trial_ary[i]
self.mol_qm.set_potential_energy(ene_qmmm_pro)
self.alpha_save += alpha
self.beta_save += beta
self.gamma_save += gamma
else:
self.mol_qm.set_positions(x_mol_save)
else:
self.count_mm += 1
if self.which_frozen[ind]: return
x_save = copy(self.mol.get_positions()[ind])
if self.pot.get_check_pbc():
self.mol.set_positions_index(ind, self.pot.get_pbc_adjusted(x_save \
+ self.delta[ind] * random_v(3)))
else:
self.mol.set_positions_index(ind, x_save \
+ self.delta[ind] * random_v(3))
int_trial = self.pot.get_interaction_energy_mc(ind)
int_trial_qmmm = self.pot_qmmm.get_interaction_energy_mc(ind)
delta_e_mm = np.sum(int_trial) - sum(self.interaction_save[ind])
delta_e_qmmm = int_trial_qmmm - self.interaction_qmmm_save[ind]
delta_e = delta_e_mm + delta_e_qmmm
if delta_e < 0.0: judge = True
else:
try:
judge = exp(-self.beta * delta_e) > random()
except OverflowError:
judge = False
# the trial movement is judged
if judge:
self.count_accept_mm += 1
self.interaction_save[ind, :] = int_trial
self.interaction_save[:, ind] = int_trial
self.interaction_qmmm_save[ind] = int_trial_qmmm
self.mol.set_potential_energy(self.mol.get_potential_energy() +
delta_e_mm)
self.mol_qm.set_potential_energy(
self.mol_qm.get_potential_energy() + delta_e_qmmm)
else:
self.mol.set_positions_index(ind, x_save)
def step(self):
# select the transfered atom
ind = randint(0, len(self.mol) - 1)
if ind in self.treated_as_molecule:
self.count_tot_mol += 1
x_mol_save = copy(
self.mol.get_positions_index(self.treated_as_molecule))
#print euler_rotation(*self.delta_mol) * x_mol_save.T
alpha, beta, gamma = self.delta_mol[1] * random_v(3)
alpha *= pi
beta *= pi * 0.5
gamma *= pi
x_mol_try = (euler_rotation(alpha, beta, gamma) * x_mol_save.T).T
x_mol_try += self.delta_mol[0] * random_v(self.mol.get_ndims())
self.mol.set_positions_index(self.treated_as_molecule, x_mol_try)
int_trial_matrix = np.array([
self.pot.get_interaction_energy(i)
for i in self.treated_as_molecule
])
int_save_matrix = np.array(
[self.interaction_save[i] for i in self.treated_as_molecule])
delta_e = np.sum(int_trial_matrix) - np.sum(int_save_matrix)
try:
judge = exp(-self.beta * delta_e) > random()
except OverflowError:
if delta_e < 0: judge = True
else: judge = False
# the trial movement is judged
if judge:
self.count_accept_mol += 1
for i in self.treated_as_molecule:
self.interaction_save[i, :] = int_trial_matrix[i]
for i in self.treated_as_molecule:
self.interaction_save[:, i] = int_trial_matrix[i]
self.mol.set_potential_energy(self.mol.get_potential_energy() +
delta_e)
self.alpha_save += alpha
self.beta_save += beta
self.gamma_save += gamma
else:
self.mol.set_positions_index(self.treated_as_molecule,
x_mol_save)
else:
self.count_tot += 1
if self.which_frozen[ind]: return
x_save = copy(self.mol.get_positions_index(ind))
if self.pot.get_check_pbc():
self.mol.set_positions_index(ind, self.pot.get_pbc_adjusted(x_save \
+ self.delta[ind] * random_v(self.mol.get_ndims())))
else:
self.mol.set_positions_index(ind, x_save \
+ self.delta[ind] * random_v(self.mol.get_ndims()))
int_trial = self.pot.get_interaction_energy(ind)
delta_e = np.sum(int_trial) - np.sum(self.interaction_save[ind])
try:
judge = exp(-self.beta * delta_e) > random()
except OverflowError:
if delta_e < 0: judge = True
else: judge = False
# the trial movement is judged
if judge:
self.count_accept += 1
self.interaction_save[ind, :] = int_trial
self.interaction_save[:, ind] = int_trial
self.mol.set_potential_energy(self.mol.get_potential_energy() +
delta_e)
else:
self.mol.set_positions_index(ind, x_save)
