def run_experiment(n_geodesic_step_list=range(1, 5), n_protocol_samples=500, protocol_length=100, collision_rate="high"): if collision_rate == "high": gamma = 91.0 / unit.picosecond elif collision_rate == "low": gamma = 1.0 / unit.picosecond else: print("Defaulting to low collision_rate") gamma = 1.0 / unit.picosecond system_name = "dhfr_constrained" equilibrium_simulator = dhfr_constrained target_filename = os.path.join( DATA_PATH, "gbaoab_{}_{}_collision_rate.pkl".format(system_name, collision_rate)) timesteps = np.linspace(1.0, 8.0, 7) noneq_simulators = {} for timestep in timesteps: for n_geodesic_steps in n_geodesic_step_list: name = "g-BAOAB ({})".format(n_geodesic_steps) Rs = ["R"] * n_geodesic_steps scheme = " ".join(["V"] + Rs + ["O"] + Rs + ["V"]) noneq_simulators[(name, timestep)] = scheme results = {} for marginal in ["configuration", "full"]: results[marginal] = {} for ((name, timestep), scheme) in noneq_simulators.items(): print(marginal, name, timestep) simulator = NonequilibriumSimulator( equilibrium_simulator, LangevinSplittingIntegrator(splitting=scheme, timestep=timestep * unit.femtosecond, collision_rate=gamma)) results[marginal][name] = simulator.collect_protocol_samples( n_protocol_samples, protocol_length, marginal) del (simulator) gc.collect() DeltaF_neq, squared_uncertainty = estimate_nonequilibrium_free_energy( *results[marginal][name]) print("\t{:.3f} +/- {:.3f}".format(DeltaF_neq, np.sqrt(squared_uncertainty))) with open(target_filename, "wb") as f: pickle.dump(results, f) plot_scheme_comparison(target_filename, system_name)
def run(self): exp = self.experiment_descriptor simulator = NonequilibriumSimulator(exp.equilibrium_simulator, ContinuousLangevinSplittingIntegrator( 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)) DeltaF_neq, squared_uncertainty = estimate_nonequilibrium_free_energy(self.result[0], self.result[1]) print(self) print("\t{:.3f} +/- {:.3f}".format(DeltaF_neq, np.sqrt(squared_uncertainty)))
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
if __name__ == "__main__": n_protocol_samples, protocol_length = 10000, 100 system_name = "alanine_unconstrained_low_friction" equilibrium_simulator = alanine_unconstrained target_filename = os.path.join(DATA_PATH, "baoab_vs_vvvr_{}.pkl".format(system_name)) schemes = {"BAOAB": "V R O R V", "VVVR": "O V R V O"} timesteps = np.linspace(0.1, 3, 10) noneq_simulators = {} for name, scheme in schemes.items(): for timestep in timesteps: noneq_simulators[(name, timestep)] = NonequilibriumSimulator( equilibrium_simulator, LangevinSplittingIntegrator( splitting=scheme, timestep=timestep * unit.femtosecond, collision_rate=1.0 / unit.picoseconds)) results = {} for marginal in ["configuration", "full"]: results[marginal] = {} for name, simulator in noneq_simulators.items(): print(marginal, name) results[marginal][name] = simulator.collect_protocol_samples( n_protocol_samples, protocol_length, marginal) DeltaF_neq, squared_uncertainty = estimate_nonequilibrium_free_energy( *results[marginal][name]) print("\t{:.3f} +/- {:.3f}".format(DeltaF_neq, np.sqrt(squared_uncertainty)))
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 with open("error_thresholds.pkl", "wb") as f:
if __name__ == "__main__": n_protocol_samples, protocol_length = 100, 100 target_filename = os.path.join(DATA_PATH, "self_averaging_experiment.pkl") scheme = "V R O R V" results = {} coupling_strengths = np.linspace(0.0, 10000.0, 10) for coupling_strength in coupling_strengths: eq_sim = oscillator_factory(coupling_strength) integrator = LangevinSplittingIntegrator(splitting=scheme, temperature=temperature, timestep=3.5 * unit.femtosecond) noneq_sim = NonequilibriumSimulator(eq_sim, integrator) W_shads = np.zeros(n_protocol_samples) for i in tqdm(range(n_protocol_samples)): x_0 = eq_sim.sample_x_from_equilibrium() v_0 = eq_sim.sample_v_given_x(x_0) W_shads[i] = noneq_sim.accumulate_shadow_work( x_0, v_0, protocol_length) print("\n\nmean(W) = {:.3f}, stdev(W) = {:.3f}\n\n".format( np.mean(W_shads), np.std(W_shads))) results[coupling_strength] = W_shads with open(target_filename, "wb") as f: pickle.dump(results, f)