def update_potential(self, pot_r, r_switch=None):
"""Update the potential using all states. """
self.previous_potential = np.copy(self.potential)
for state in self.states:
kT = state.kT
alpha0 = self.states[state]['alpha']
form = self.states[state]['alpha_form']
alpha = alpha_array(alpha0, pot_r, form=form)
current_rdf = self.states[state]['current_rdf'][:, 1]
target_rdf = self.states[state]['target_rdf'][:, 1]
# For cases where rdf_cutoff != pot_cutoff, only update the
# potential using RDF values < pot_cutoff.
unused_rdf_vals = current_rdf.shape[0] - self.potential.shape[0]
if unused_rdf_vals != 0:
current_rdf = current_rdf[:-unused_rdf_vals]
target_rdf = target_rdf[:-unused_rdf_vals]
# The actual IBI step.
self.potential += (kT * alpha * np.log(current_rdf / target_rdf) /
len(self.states))
# Apply corrections to ensure continuous, well-behaved potentials.
self.potential = tail_correction(pot_r, self.potential, r_switch)
self.potential = head_correction(pot_r, self.potential,
self.previous_potential, self.head_correction_form)
def update_potential(self, pot_r, r_switch=None):
"""Update the potential using all states. """
self.previous_potential = np.copy(self.potential)
for state in self.states:
kT = state.kT
alpha0 = self.states[state]['alpha']
form = self.states[state]['alpha_form']
alpha = alpha_array(alpha0, pot_r, form=form)
current_rdf = self.states[state]['current_rdf'][:, 1]
target_rdf = self.states[state]['target_rdf'][:, 1]
# For cases where rdf_cutoff != pot_cutoff, only update the
# potential using RDF values < pot_cutoff.
unused_rdf_vals = current_rdf.shape[0] - self.potential.shape[0]
if unused_rdf_vals != 0:
current_rdf = current_rdf[:-unused_rdf_vals]
target_rdf = target_rdf[:-unused_rdf_vals]
# The actual IBI step.
self.potential += (kT * alpha * np.log(current_rdf / target_rdf) /
len(self.states))
# Apply corrections to ensure continuous, well-behaved potentials.
self.potential = tail_correction(pot_r, self.potential, r_switch)
self.potential = head_correction(pot_r, self.potential,
self.previous_potential,
self.head_correction_form)
def update_potential(self, pot_r, r_switch=None, verbose=False):
"""Update the potential using all states. """
self.previous_potential = np.copy(self.potential)
for state in self.states:
kT = state.kT
alpha0 = self.states[state]["alpha"]
form = self.states[state]["alpha_form"]
alpha = alpha_array(alpha0, pot_r, form=form)
current_rdf = self.states[state]["current_rdf"][:, 1]
target_rdf = self.states[state]["target_rdf"][:, 1]
# For cases where rdf_cutoff != pot_cutoff, only update the
# potential using RDF values < pot_cutoff.
unused_rdf_vals = current_rdf.shape[0] - self.potential.shape[0]
if unused_rdf_vals != 0:
current_rdf = current_rdf[:-unused_rdf_vals]
target_rdf = target_rdf[:-unused_rdf_vals]
if verbose: # pragma: no cover
plt.plot(current_rdf, label="current rdf")
plt.plot(target_rdf, label="target rdf")
plt.legend()
plt.show()
# The actual IBI step.
self.potential += (kT * alpha * np.log(current_rdf / target_rdf) /
len(self.states))
if verbose: # pragma: no cover
plt.plot(pot_r,
self.previous_potential,
label="previous potential")
plt.plot(pot_r, self.potential, label="potential")
plt.legend()
plt.show()
# Apply corrections to ensure continuous, well-behaved potentials.
if verbose: # pragma: no cover
plt.plot(pot_r, self.potential, label="uncorrected potential")
self.potential = tail_correction(pot_r, self.potential, r_switch)
if verbose: # pragma: no cover
plt.plot(pot_r, self.potential, label="tail correction")
self.potential = head_correction(pot_r, self.potential,
self.previous_potential,
self.head_correction_form)
if verbose: # pragma: no cover
plt.plot(pot_r, self.potential, label="head correction")
plt.legend()
plt.show()
def initialize(self, engine='hoomd', potentials_dir=None):
"""
Create initial table potentials and the simulation input scripts.
Parameters
----------
engine : str, optional, default='hoomd'
Engine used to run simulations
potentials_dir : path, optional, default="'working_dir'/potentials"
Directory to store potential files
"""
if not potentials_dir:
self.potentials_dir = os.path.join(os.getcwd(), 'potentials')
else:
self.potentials_dir = potentials_dir
if not os.path.isdir(self.potentials_dir):
os.mkdir(self.potentials_dir)
if not os.path.isdir('rdfs'):
os.mkdir('rdfs')
table_potentials = []
for pair in self.pairs:
potential_file = os.path.join(self.potentials_dir,
'pot.{0}.txt'.format(pair.name))
pair.potential_file = potential_file
table_potentials.append((pair.type1, pair.type2, potential_file))
V = tail_correction(self.pot_r, pair.potential, self.r_switch)
pair.potential = V
# This file is written for viewing of how the potential evolves.
pair.save_table_potential(self.pot_r, self.dr, iteration=0,
engine=engine)
# This file is overwritten at each iteration and actually used for
# performing the query simulations.
pair.save_table_potential(self.pot_r, self.dr, engine=self.engine)
for state in self.states:
if self.engine == 'hoomd':
state.save_runscript(table_potentials, table_width=len(self.pot_r),
engine=self.engine)
elif self.engine == 'lammps':
state.save_runscript(table_potentials=table_potentials, table_width=0,
engine=self.engine)
def initialize(self, engine="hoomd", potentials_dir=None):
"""
Create initial table potentials and the simulation input scripts.
Parameters
----------
engine : str, optional, default='hoomd'
Engine used to run simulations
potentials_dir : path, optional, default="'working_dir'/potentials"
Directory to store potential files
"""
if not potentials_dir:
self.potentials_dir = os.path.join(os.getcwd(), "potentials")
else:
self.potentials_dir = potentials_dir
if not os.path.isdir(self.potentials_dir):
os.mkdir(self.potentials_dir)
if not os.path.isdir("rdfs"):
os.mkdir("rdfs")
table_potentials = []
for pair in self.pairs:
potential_file = os.path.join(self.potentials_dir,
"pot.{0}.txt".format(pair.name))
pair.potential_file = potential_file
table_potentials.append((pair.type1, pair.type2, potential_file))
V = tail_correction(self.pot_r, pair.potential, self.r_switch)
pair.potential = V
# This file is written for viewing of how the potential evolves.
pair.save_table_potential(self.pot_r,
self.dr,
iteration=0,
engine=engine)
# This file is overwritten at each iteration and actually used for
# performing the query simulations.
pair.save_table_potential(self.pot_r, self.dr, engine=engine)
for state in self.states:
state.save_runscript(table_potentials,
table_width=len(self.pot_r),
engine=engine)
r[last_bad_index + 1:last_bad_index + 3],
potential[last_bad_index + 2:last_bad_index + 0:-1],
fill_value='extrapolate')
else:
f = scipy.interpolate.interp1d(
r[last_bad_index + 1:last_bad_index + 3],
potential[last_bad_index + 1:last_bad_index + 3],
fill_value='extrapolate')
for i in np.arange(last_bad_index + 1):
potential[i] = f(r[i])
return potential
rdfs = glob.glob('*-flhe_nvt.txt')
kT = 2.5
r_switch = 1.1
for rdf_file in rdfs:
filename = "-".join(rdf_file.split('-')[0:2])
print(filename)
rdf = np.loadtxt(rdf_file)
dr = rdf[1, 0] - rdf[0, 0]
potential = _invert_rdf(rdf[:, 1], kT)
potential = tail_correction(rdf[:, 0], potential, r_switch)
potential = _linear_head(rdf[:, 0], potential)
forces = -1.0 * np.gradient(potential, dr)
potential = savitzky_golay(potential, 9, 2, deriv=0, rate=1)
np.savetxt(filename + ".pot",
np.column_stack((rdf[:, 0], potential, forces)))
def _initialize(self, engine, n_steps, integrator, integrator_kwargs, dt,
gsd_period, potentials_dir):
"""Create initial table potentials and the simulation input scripts.
Parameters
----------
engine : str, default 'hoomd'
Engine used to run simulations
potentials_dir : path, default None
Directory to store potential files. If None is given, a "potentials"
folder in the current working directory is used.
"""
if potentials_dir is None:
self.potentials_dir = os.path.join(os.getcwd(), "potentials")
else:
self.potentials_dir = potentials_dir
if not os.path.isdir(self.potentials_dir):
os.mkdir(self.potentials_dir)
if not os.path.isdir("rdfs"):
os.mkdir("rdfs")
table_potentials = []
bonds = None
angles = None
for pair in self.pairs:
potential_file = os.path.join(self.potentials_dir,
f"pot.{pair.name}.txt")
pair.potential_file = potential_file
table_potentials.append((pair.type1, pair.type2, potential_file))
V = tail_correction(self.pot_r, pair.potential, self.r_switch)
pair.potential = V
# This file is written for viewing of how the potential evolves.
pair.save_table_potential(self.pot_r,
self.dr,
iteration=0,
engine=engine)
# This file is overwritten at each iteration and actually used for
# performing the query simulations.
pair.save_table_potential(self.pot_r, self.dr, engine=engine)
if self.bonds:
bonds = self.bonds
if self.angles:
angles = self.angles
for state in self.states:
state.save_runscript(n_steps=n_steps,
integrator=integrator,
integrator_kwargs=integrator_kwargs,
dt=dt,
gsd_period=gsd_period,
table_potentials=table_potentials,
table_width=len(self.pot_r),
engine=engine,
bonds=bonds,
angles=angles)
def test_tail_correction():
dr = 0.05
r = np.arange(0, 2.5, dr)
V = mie(r, 1, 1)
smooth_V = tail_correction(r, V, r_switch=2.25)
assert smooth_V[-1] == 0.0
def test_tail_correction():
dr = 0.05
r = np.arange(0, 2.5, dr)
V = mie(r, 1, 1)
smooth_V = tail_correction(r, V, r_switch=2.25)
assert smooth_V[-1] == 0.0
def update_potential(self, pot_r, r_switch=None, verbose=False):
"""Update the potential using all states. """
self.previous_potential = np.copy(self.potential)
for state in self._states:
kT = state.kT
alpha0 = self._states[state]["alpha"]
form = self._states[state]["alpha_form"]
alpha = alpha_array(alpha0, pot_r, form=form)
current_rdf = self._states[state]["current_rdf"]
target_rdf = self._states[state]["target_rdf"]
# For cases where rdf_cutoff != pot_cutoff, only update the
# potential using RDF values < pot_cutoff.
unused_rdf_vals = current_rdf.shape[0] - self.potential.shape[0]
if unused_rdf_vals != 0:
current_rdf = current_rdf[:-unused_rdf_vals,:]
target_rdf = target_rdf[:-unused_rdf_vals,:]
if verbose: # pragma: no cover
plt.plot(current_rdf[:,0], current_rdf[:,1], label="current rdf")
plt.plot(target_rdf[:,0], target_rdf[:,1], label="target rdf")
plt.legend()
plt.show()
# The actual IBI step.
self.potential += (
kT * alpha * np.log(current_rdf[:,1] / target_rdf[:,1]) / len(self._states)
)
if verbose: # pragma: no cover
plt.plot(
pot_r, self.previous_potential, label="previous potential"
)
plt.plot(pot_r, self.potential, label="potential")
plt.ylim(
(min(self.potential[np.isfinite(self.potential)])-1,10)
)
plt.legend()
plt.show()
# Apply corrections to ensure continuous, well-behaved potentials.
pot = self.potential
self.potential = tail_correction(pot_r, self.potential, r_switch)
tail = self.potential
self.potential = head_correction(
pot_r,
self.potential,
self.previous_potential,
self.head_correction_form
)
head = self.potential
if verbose: # pragma: no cover
plt.plot(pot_r, head, label="head correction")
plt.plot(pot_r, pot, label="uncorrected potential")
idx_r, _ = find_nearest(pot_r, r_switch)
plt.plot(pot_r[idx_r:], tail[idx_r:], label="tail correction")
plt.ylim((min(pot[np.isfinite(pot)])-1, 10))
plt.legend()
plt.show()