def compute_current_rdf(self, state, r_range, n_bins, smooth=True, max_frames=1e3): """ """ pairs = self.states[state]['pair_indices'] # TODO: More elegant way to handle units. # See https://github.com/ctk3b/msibi/issues/2 g_r_all = None first_frame = 0 max_frames = int(max_frames) for last_frame in range(max_frames, state.traj.n_frames + max_frames, max_frames): r, g_r = md.compute_rdf(state.traj[first_frame:last_frame], pairs, r_range= r_range, n_bins=n_bins) if g_r_all is None: g_r_all = np.zeros_like(g_r) g_r_all += g_r * len(state.traj[first_frame:last_frame]) / state.traj.n_frames first_frame = last_frame #r *= 10.0 rdf = np.vstack((r, g_r)).T self.states[state]['current_rdf'] = rdf if smooth: current_rdf = self.states[state]['current_rdf'] current_rdf[:, 1] = savitzky_golay(current_rdf[:, 1], 9, 2, deriv=0, rate=1) for row in current_rdf: row[1] = np.maximum(row[1], 0) # Compute fitness function comparing the two RDFs. f_fit = calc_similarity(rdf[:, 1], self.states[state]['target_rdf'][:, 1]) self.states[state]['f_fit'].append(f_fit)
def _add_state(self, state, smooth=True): """Add a state to be used in optimizing this pair. Parameters ---------- state : msibi.state.State A state object created previously. """ target_rdf = self.get_state_rdf(state, query=False) if state._opt.smooth_rdfs: target_rdf[:, 1] = savitzky_golay( target_rdf[:, 1], 9, 2, deriv=0, rate=1 ) negative_idx = np.where(target_rdf < 0) target_rdf[negative_idx] = 0 self._states[state] = { "target_rdf": target_rdf, "current_rdf": None, "alpha": state.alpha, "alpha_form": "linear", "pair_indices": None, "f_fit": [], "path": state.dir }
def compute_current_rdf(self, state, r_range, n_bins, smooth=True, max_frames=50, verbose=False): """ """ pairs = self.states[state]["pair_indices"] # TODO: More elegant way to handle units. # See https://github.com/ctk3b/msibi/issues/2 g_r_all = None first_frame = 0 max_frames = int(max_frames) for last_frame in range(max_frames, state.traj.n_frames + max_frames, max_frames): r, g_r = md.compute_rdf( state.traj[first_frame:last_frame], pairs, r_range=r_range / 10, n_bins=n_bins, ) if g_r_all is None: g_r_all = np.zeros_like(g_r) g_r_all += (g_r * len(state.traj[first_frame:last_frame]) / state.traj.n_frames) first_frame = last_frame r *= 10 rdf = np.vstack((r, g_r_all)).T self.states[state]["current_rdf"] = rdf if smooth: current_rdf = self.states[state]["current_rdf"] current_rdf[:, 1] = savitzky_golay(current_rdf[:, 1], 9, 2, deriv=0, rate=1) for row in current_rdf: row[1] = np.maximum(row[1], 0) if verbose: # pragma: no cover plt.title(f"RDF smoothing for {state.name}") plt.plot(r, g_r, label="unsmoothed") plt.plot(r, current_rdf[:, 1], label="smoothed") plt.legend() plt.show() # Compute fitness function comparing the two RDFs. f_fit = calc_similarity(rdf[:, 1], self.states[state]["target_rdf"][:, 1]) self.states[state]["f_fit"].append(f_fit)
def compute_current_rdf(self, state, r_range, n_bins, smooth=True, max_frames=1e3): """ """ pairs = self.states[state]['pair_indices'] # TODO: More elegant way to handle units. # See https://github.com/ctk3b/msibi/issues/2 g_r_all = None first_frame = 0 max_frames = int(max_frames) for last_frame in range(max_frames, state.traj.n_frames + max_frames, max_frames): r, g_r = md.compute_rdf(state.traj[first_frame:last_frame], pairs, r_range=r_range / 10, n_bins=n_bins) if g_r_all is None: g_r_all = np.zeros_like(g_r) g_r_all += g_r * len( state.traj[first_frame:last_frame]) / state.traj.n_frames first_frame = last_frame r *= 10 rdf = np.vstack((r, g_r_all)).T self.states[state]['current_rdf'] = rdf if smooth: current_rdf = self.states[state]['current_rdf'] current_rdf[:, 1] = savitzky_golay(current_rdf[:, 1], 9, 2, deriv=0, rate=1) for row in current_rdf: row[1] = np.maximum(row[1], 0) # Compute fitness function comparing the two RDFs. f_fit = calc_similarity(rdf[:, 1], self.states[state]['target_rdf'][:, 1]) self.states[state]['f_fit'].append(f_fit)
def test_savitzky_golay(): x = np.arange(0, 1, 0.01) y = 2 * x + 1 y2 = savitzky_golay(y, 3, 1) assert y.shape == y2.shape assert np.allclose(y, y2) y = x ** 3.0 y2 = savitzky_golay(y, 3, 1) assert calc_similarity(y, y2) > 0.99 with pytest.raises(ValueError): y2 = savitzky_golay(y, 3.1, 1) with pytest.raises(TypeError): y2 = savitzky_golay(y, 2, 1) with pytest.raises(TypeError): y2 = savitzky_golay(y, 4, 1) with pytest.raises(TypeError): y2 = savitzky_golay(y, 3, 3) with pytest.raises(TypeError): y2 = savitzky_golay(y, 3, 2)
def test_savitzky_golay(): x = np.arange(0, 1, 0.01) y = 2 * x + 1 y2 = savitzky_golay(y, 3, 1) assert y.shape == y2.shape assert np.allclose(y, y2) y = x**3.0 y2 = savitzky_golay(y, 3, 1) assert calc_similarity(y, y2) > 0.99 with pytest.raises(ValueError): y2 = savitzky_golay(y, 3.1, 1) with pytest.raises(TypeError): y2 = savitzky_golay(y, 2, 1) with pytest.raises(TypeError): y2 = savitzky_golay(y, 4, 1) with pytest.raises(TypeError): y2 = savitzky_golay(y, 3, 3) with pytest.raises(TypeError): y2 = savitzky_golay(y, 3, 2)
def compute_current_rdf(self, state, smooth, verbose=False, query=True): rdf = self.get_state_rdf(state, query=query) self._states[state]["current_rdf"] = rdf if state._opt.smooth_rdfs: current_rdf = self._states[state]["current_rdf"] current_rdf[:, 1] = savitzky_golay( current_rdf[:, 1], 9, 2, deriv=0, rate=1 ) negative_idx = np.where(current_rdf < 0) current_rdf[negative_idx] = 0 if verbose: # pragma: no cover plt.title(f"RDF smoothing for {state.name}") plt.plot(rdf[:,0], rdf[:, 1], label="unsmoothed") plt.plot(rdf[:,0], current_rdf[:,1], label="smoothed") plt.legend() plt.show() # Compute fitness function comparing the two RDFs. f_fit = calc_similarity( rdf[:, 1], self._states[state]["target_rdf"][:, 1] ) self._states[state]["f_fit"].append(f_fit)
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)))