def get_hmr_stability_threshold_curve(test_system, splitting="V R O R V", traj_length=1000): topology = test_system.topology default_system = deepcopy(test_system.system) h_masses = np.arange(0.5, 4.51, 0.25) stability_thresholds = [] for h_mass in h_masses: hmr_system = repartition_hydrogen_mass_amber(topology, default_system, scale_factor=h_mass) test_system.system = hmr_system lsi = LangevinSplittingIntegrator(splitting) simulation = test_system.construct_simulation(lsi) def stability_oracle(dt): simulation.integrator.setStepSize(dt * unit.femtoseconds) stable = test_stability(test_system, simulation, 1, traj_length) if stable: return 1 else: return -1 x, _, fs_heavy_H = probabilistic_bisection(stability_oracle, initial_limits=(0, 10), p=0.6, n_iterations=100) stability_thresholds.append(x[np.argmax(fs_heavy_H[-1])]) test_system = repartition_hydrogen_mass_amber(topology, default_system, scale_factor=1) return h_masses, stability_thresholds
def run(self): exp = self.experiment_descriptor simulator = NonequilibriumSimulator(exp.equilibrium_simulator, LangevinSplittingIntegrator( splitting=exp.splitting_string, timestep=exp.timestep_in_fs * unit.femtosecond, collision_rate=exp.collision_rate)) self.result = simulator.collect_protocol_samples( exp.n_protocol_samples, exp.protocol_length, exp.marginal, store_potential_energy_traces=(exp.marginal=="full" and self.store_potential_energy_traces)) W_shads_F, W_shads_R = self.result["W_shads_F"], self.result["W_shads_R"] DeltaF_neq, squared_uncertainty = estimate_nonequilibrium_free_energy(W_shads_F, W_shads_R) print(self) print("\t{:.3f} +/- {:.3f}".format(DeltaF_neq, np.sqrt(squared_uncertainty)))
def simulation_factory(scheme, system_loader, constrained=True): """Create and return a simulation that includes: * Langevin integrator with the prescribed operator splitting * AlanineDipeptideVacuum with or without restraints.""" platform = configure_platform("Reference") temperature = simulation_parameters["temperature"] topology, system, positions = system_loader(constrained) lsi = LangevinSplittingIntegrator(scheme, temperature=temperature, timestep=2.0 * unit.femtosecond, measure_heat=True, measure_shadow_work=True) simulation = app.Simulation(topology, system, lsi, platform) simulation.context.setPositions(positions) simulation.context.setVelocitiesToTemperature(temperature) return simulation
def noneq_sim_factory(testsystem_name, scheme, dt, collision_rate): """Generate a NonequilibriumSimulator object for a given experiment Parameters ---------- testsystem_name : string scheme : string dt : in units compatible with unit.femtosecond collision_rate : in units compatible with (1 / unit.picosecond) Returns ------- noneq_sim : NonequilibriumSimulator """ # check that testsystem_name is valid assert (testsystem_name in testsystems) # check that scheme is valid assert (scheme in splittings) # check that dt is valid assert (type(dt) == unit.Quantity) assert (dt.unit.is_compatible(unit.femtosecond)) # check that collision_rate is valid assert (type(collision_rate) == unit.Quantity) assert ((1 / collision_rate).unit.is_compatible(unit.picosecond)) testsystem = testsystems[testsystem_name] integrator = LangevinSplittingIntegrator(splittings[scheme], temperature=temperature, collision_rate=collision_rate, timestep=dt) noneq_sim = NonequilibriumSimulator(testsystem, integrator) return noneq_sim
def error_oracle_factory(test_system, error_threshold, scheme="O V R V O", n_protocol_samples=100, protocol_length=1000): integrator = LangevinSplittingIntegrator(scheme, timestep=1.0 * unit.femtosecond) sim = NonequilibriumSimulator(test_system, integrator) def error_oracle(dt): integrator.setStepSize(dt * unit.femtosecond) W_F, W_R = sim.collect_protocol_samples(n_protocol_samples, protocol_length) DeltaF_neq, sq_unc = estimate_nonequilibrium_free_energy(W_F, W_R) print("\t{:.3f} +/- {:.3f}".format(DeltaF_neq, np.sqrt(sq_unc))) if error_threshold > np.abs(DeltaF_neq): return 1 else: return -1 return error_oracle
def integrator_factory(dt): return LangevinSplittingIntegrator(collision_rate=91.0 / unit.picosecond, timestep=dt)
DeltaF_neq, sq_unc = estimate_nonequilibrium_free_energy(W_F, W_R) print("\t{:.3f} +/- {:.3f}".format(DeltaF_neq, np.sqrt(sq_unc))) if error_threshold > np.abs(DeltaF_neq): return 1 else: return -1 return error_oracle if __name__ == "__main__": test_system = alanine_constrained reference_integrator = LangevinSplittingIntegrator("O V R V O", timestep=2.0 * unit.femtosecond) reference_sim = NonequilibriumSimulator(test_system, reference_integrator) W_F, W_R = reference_sim.collect_protocol_samples(1000, 1000) DeltaF_neq, sq_unc = estimate_nonequilibrium_free_energy(W_F, W_R) results = {} for scheme in ["V R O R V", "R V O V R", "O V R V O", "O R V R O"]: print(scheme) error_oracle = error_oracle_factory(DeltaF_neq, scheme) results[scheme] = probabilistic_bisection(error_oracle, (0, 10), n_iterations=100) from pickle import dump
from benchmark.testsystems.bookkeepers import EquilibriumSimulator top, sys, pos = load_alanine(constrained=True) alanine_constrained = EquilibriumSimulator( platform=configure_platform("Reference"), topology=top, system=sys, positions=pos, temperature=temperature, timestep=1.0 * unit.femtosecond, burn_in_length=500, n_samples=n_samples, thinning_interval=thinning_interval, name="alanine_constrained_test") print("Sample from cache: \n", alanine_constrained.sample_x_from_equilibrium()) sim = NonequilibriumSimulator( alanine_constrained, LangevinSplittingIntegrator("O V R V O", timestep=4.5 * unit.femtoseconds)) result = sim.collect_protocol_samples(100, 100, store_potential_energy_traces=True, store_W_shad_traces=True) print("<W>_(0 -> M): {:.3f}, <W>_(M -> 2M): {:.3f}".format( result["W_shads_F"].mean(), result["W_shads_R"].mean())) forward_traces = np.array([t[0] for t in result["W_shad_traces"]]) print("0 -> M traces: mean W_shad per step: ", forward_traces.mean(0)) print("0 -> M traces: mean cumulative W_shad per step: ", np.cumsum(forward_traces, 1).mean(0))