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)