def test_vhf_from_pvhf():
trj = md.load(get_fn("spce.xtc"), top=get_fn("spce.gro"))
unique_atoms = get_unique_atoms(trj)
tuples_combination = combinations_with_replacement(unique_atoms, 2)
# obtaining g_r_t from total func
chunk_length = 20
r, t, g_r_t = compute_van_hove(trj, chunk_length=chunk_length)
partial_dict = compute_van_hove(trj, chunk_length=chunk_length, partial=True)
# obtating dict of np.array of pvhf
partial_dict = {}
for pairs in tuples_combination:
pair1 = pairs[0]
pair2 = pairs[1]
# Set in alphabetical order
if pairs[0].name > pairs[1].name:
pair2 = pairs[0]
pair1 = pairs[1]
x = compute_partial_van_hove(
trj,
chunk_length=chunk_length,
selection1=f"name {pair1.name}",
selection2=f"name {pair2.name}",
)
partial_dict[pairs] = x[1]
# obtaining total_grt from partial
total_g_r_t = vhf_from_pvhf(trj, partial_dict)
assert np.allclose(g_r_t, total_g_r_t)
def test_van_hove_equal():
trj = md.load(get_fn("spce.xtc"), top=get_fn("spce.gro"))
chunk_length = 2
r_p, t_p, g_r_t_p = compute_van_hove(trj, chunk_length=chunk_length)
r_s, t_s, g_r_t_s = compute_van_hove(trj, chunk_length=chunk_length, parallel=False)
assert np.allclose(r_p, r_s)
assert np.allclose(t_p, t_s)
assert np.allclose(g_r_t_p, g_r_t_s)
def test_self_warning(parallel):
trj = md.load(get_fn("spce.xtc"), top=get_fn("spce.gro"))
chunk_length = 2
with pytest.warns(UserWarning, match=r"Total VHF"):
compute_van_hove(
trj,
chunk_length=chunk_length,
self_correlation=True,
parallel=parallel,
)
def test_van_hove():
trj = md.load(get_fn("spce.xtc"), top=get_fn("spce.gro"))
chunk_length = 2
r, t, g_r_t = compute_van_hove(trj, chunk_length=chunk_length)
assert len(t) == 2
assert len(r) == 200
assert np.shape(g_r_t) == (2, 200)
# Check normalization to ~1
assert 0.95 < np.mean(g_r_t[:, -10:]) < 1.05
fig, ax = plt.subplots()
for i in range(len(t)):
ax.plot(r, g_r_t[i], ".-", label=t[i])
ax.set_ylim((0, 3))
ax.legend()
fig.savefig("vhf.pdf")
def test_serial_van_hove():
trj = md.load(get_fn("spce.xtc"), top=get_fn("spce.gro"))
chunk_length = 2
r, t, g_r_t = compute_van_hove(trj, chunk_length=chunk_length, parallel=False)
def run_total_vhf(trj,
chunk_length,
n_chunks,
step=1,
parallel=False,
water=True,
r_range=(0, 1.0),
bin_width=0.005,
n_bins=None,
self_correlation=True,
periodic=True,
opt=True,
partial=False):
""" Run `calculate_van_hove` for specific number of number of chunks
and chunk_length
Parameters
----------
trj : MDTraj.Trajectory
MDTraj trajectory
chunk_length : int
Number of frames in chunk
n_chunks : int
Number of chunks to average over
step : int, default=1
Step interval of frames to analyze
parallel : bool, default=True
Use parallel implementation with `multiprocessing`
water : bool
use X-ray form factors for water that account for polarization
r_range : array-like, shape=(2,), optional, default=(0.0, 1.0)
Minimum and maximum radii.
bin_width : float, optional, default=0.005
Width of the bins in nanometers.
n_bins : int, optional, default=None
The number of bins. If specified, this will override the `bin_width`
parameter.
self_correlation : bool, default=True
Whether or not to include the self-self correlations
Return
------
r : numpy.array
Distances
t : numpy.array
times
g_r_t : numpy.array
van hove function averaged over n_chunks
"""
# Calculate intervals between starting points
starting_frames = np.linspace(0,
trj.n_frames - chunk_length,
n_chunks,
dtype=int)
if step != 1:
frames_in_chunk = int(chunk_length / step)
else:
frames_in_chunk = chunk_length
vhf_list = list()
for idx, start in enumerate(starting_frames):
end = start + chunk_length
chunk = trj[start:end:step]
print(f"Analyzing frames {start} to {end}...")
r, t, g_r_t = compute_van_hove(
trj=chunk,
chunk_length=frames_in_chunk,
parallel=parallel,
water=water,
r_range=r_range,
bin_width=bin_width,
n_bins=n_bins,
self_correlation=self_correlation,
periodic=periodic,
opt=opt,
partial=partial,
)
vhf_list.append(g_r_t)
vhf_mean = np.mean(vhf_list, axis=0)
t_save = t - t[0]
return r, t_save, vhf_mean