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