def test_multi_run():
# NEB
geoms = AnaPot().get_path(10)
cos = NEB(geoms)
neb_kwargs = {
"dump": True,
"h5_group_name": "neb",
}
neb_opt = SteepestDescent(cos, **neb_kwargs)
neb_opt.run()
# GrowingString
geoms = AnaPot().get_path(10)
gsm = GrowingString(geoms, calc_getter=AnaPot, perp_thresh=0.25)
gsm_kwargs = {
"dump": True,
"h5_group_name": "gsm",
"stop_in_when_full": 0,
}
gsm_opt = StringOptimizer(gsm, **gsm_kwargs)
gsm_opt.run()
# calc = geoms[0].calculator
# calc.anim_opt(opt, show=True)
# Simple Optimization
geom = AnaPot().get_path(10)[5]
opt_kwargs = {
"dump": True,
"h5_group_name": "opt",
}
opt = RFOptimizer(geom, **opt_kwargs)
opt.run()
def test_dump_neb():
# NEB
geoms = AnaPot().get_path(10)
cos = NEB(geoms)
opt_kwargs = {
"dump": True,
# "rms_force": 1.0,
"h5_group_name": "neb",
}
opt = SteepestDescent(cos, **opt_kwargs)
# opt = SteepestDescent(geoms[7], **opt_kwargs)
opt.run()
# GrowingString
geoms = AnaPot().get_path(10)
gsm = GrowingString(geoms, calc_getter=AnaPot, perp_thresh=0.25)
opt_kwargs = {
"dump": True,
"h5_group_name": "gsm",
"gamma": 10.,
"stop_in_when_full": 0,
}
opt = StringOptimizer(gsm, **opt_kwargs)
opt.run()
calc = geoms[0].calculator
# calc.anim_opt(opt, show=True)
# # Simple Optimization
# geom = AnaPot().get_path(10)[5]
# opt_kwargs = {
# "dump": True,
# "h5_group_name": "opt",
# }
# opt = RFOptimizer(geom, **opt_kwargs)
# opt.run()
return
hei_coords, *_ = cos.get_splined_hei()
ts_geom = geoms[0].copy()
ts_geom.coords = hei_coords
ts_geom.set_calculator(AnaPot())
ts_opt_kwargs = {
# "dump": True,
"thresh": "gau_tight",
}
ts_opt = RSIRFOptimizer(ts_geom, **ts_opt_kwargs)
ts_opt.run()
def test_mullerbrown_neb(k, ref_cycle):
geoms = MullerBrownPot().get_path(num=17)
cos = NEB(geoms, k_max=k, k_min=k)
cos.printf = False
cos.onlyone = False
opt_kwargs = {
"max_step": 0.04,
"gamma_mult": True,
"keep_last": 10,
"max_cycles": 100,
}
opt = LBFGS(cos, **opt_kwargs)
opt.run()
assert opt.is_converged
assert opt.cur_cycle == ref_cycle
def test_psi4_neb():
start = geom_from_library("hcn.xyz")
ts = geom_from_library("hcn_iso_ts_guess.xyz")
end = geom_from_library("nhc.xyz")
images = interpolate_all((start, ts, end), 4, kind="lst")
for i, img in enumerate(images):
img.set_calculator(Psi4("tpss", "sto-3g", pal=4, calc_number=i))
neb = NEB(images, climb=True)
with open("interpolated.trj", "w") as handle:
handle.write(neb.as_xyz())
# qm = QuickMin(neb, align=True, dump=True, max_cycles=10)
# qm.run()
fire = FIRE(neb, align=True, dump=True, max_cycles=10)
fire.run()
lbfgs = LBFGS(neb, align=True, dump=True)
lbfgs.run()
def test_fire_neb():
kwargs = copy.copy(KWARGS)
neb = NEB(get_geoms())
opt = run_cos_opt(neb, FIRE, **kwargs)
assert (opt.is_converged)
assert (opt.cur_cycle == 18)
return opt
def test_bfgs_neb():
kwargs = copy.copy(KWARGS)
#kwargs["max_cycles"] = 18
neb = NEB(get_geoms())
opt = run_cos_opt(neb, BFGS, **kwargs)
assert (opt.is_converged)
return opt
def test_steepest_descent_neb():
kwargs = copy.copy(KWARGS)
neb = NEB(get_geoms())
opt = run_cos_opt(neb, SteepestDescent, **kwargs)
assert (opt.is_converged)
assert (opt.cur_cycle == 24)
return opt
def test_steepest_descent_neb_more_images():
kwargs = copy.copy(KWARGS)
kwargs["images"] = 20
neb = NEB(get_geoms())
opt = run_cos_opt(neb, SteepestDescent, **kwargs)
assert (opt.is_converged)
assert (opt.cur_cycle == 29)
return opt
def test_fire_neb():
kwargs = copy.copy(KWARGS)
kwargs["dt"] = 0.01
kwargs["dt_max"] = 0.1
neb = NEB(get_geoms())
opt = run_cos_opt(neb, FIRE, **kwargs)
assert (opt.is_converged)
assert (opt.cur_cycle == 76)
return opt
def test_neb_springs(neb_kwargs, ref_cycle):
calc = AnaPot()
geoms = calc.get_path(15)
neb = NEB(geoms, **neb_kwargs)
opt = SteepestDescent(neb)
opt.run()
# calc.anim_opt(opt, show=True)
assert (opt.is_converged)
assert (opt.cur_cycle == ref_cycle)
def plot_cosgrad():
keys = ("energy", "forces", "coords")
(energies, forces, coords), num_cycles, num_images = load_results(keys)
atom_num = coords[0][0].size // 3
dummy_atoms = ["H"] * atom_num
all_nebs = list()
all_perp_forces = list()
for i, per_cycle in enumerate(zip(energies, forces, coords), 1):
ens, frcs, crds = per_cycle
images = [Geometry(dummy_atoms, per_image) for per_image in crds]
for image, en, frc in zip(images, ens, frcs):
image._energy = en
image._forces = frc
neb = NEB(images)
all_nebs.append(neb)
pf = neb.perpendicular_forces.reshape(num_images, -1)
all_perp_forces.append(pf)
# Calculate norms of true force
# Shape (cycles, images, coords)
force_norms = np.linalg.norm(forces, axis=2)
all_max_forces = list()
all_rms_forces = list()
rms = lambda arr: np.sqrt(np.mean(np.square(arr)))
for pf in all_perp_forces:
max_forces = pf.max(axis=1)
all_max_forces.append(max_forces)
rms_forces = np.apply_along_axis(rms, 1, pf)
all_rms_forces.append(rms_forces)
all_max_forces = np.array(all_max_forces)
all_rms_forces = np.array(all_rms_forces)
fig, (ax0, ax1, ax2) = plt.subplots(sharex=True, nrows=3)
def plot(ax, data, title):
colors = matplotlib.cm.Greys(np.linspace(0, 1, num=data.shape[0]))
for row, color in zip(data, colors):
ax.plot(row, "o-", color=color)
ax.set_yscale('log')
if title:
ax.set_title(title)
plot(ax0, all_max_forces, "max(perpendicular gradient)")
plot(ax1, all_rms_forces, "rms(perpendicular gradient)")
plot(ax2, force_norms, "norm(true gradient)")
ax2.set_xlabel("Images")
plt.tight_layout()
plt.show()
def test_lbfgs_neb():
kwargs = copy.copy(KWARGS)
kwargs["images"] = 3
kwargs["fix_ends"] = True
k_min = 1000
k_max = k_min + 10
neb = NEB(get_geoms(("A", "B")), k_min=k_min, k_max=k_max, fix_ends=True)
from pysisyphus.optimizers.ConjugateGradient import ConjugateGradient
# from pysisyphus.optimizers.LBFGS_mod import LBFGS
opt = run_cos_opt(neb, LBFGS, **kwargs)
# assert(opt.is_converged)
# assert(opt.cur_cycle == 45)
return opt
def test_steepest_descent_neb_more_images():
kwargs = copy.copy(KWARGS)
kwargs["images"] = 7
convergence = {
"max_force_thresh": 0.6,
"rms_force_thresh": 0.13,
"max_step_thresh": 0.015,
"rms_step_thresh": 0.0033,
}
kwargs["convergence"] = convergence
neb = NEB(get_geoms())
opt = run_cos_opt(neb, SteepestDescent, **kwargs)
assert (opt.is_converged)
assert (opt.cur_cycle == 41)
return opt
def test_dask():
with LocalCluster(n_workers=2) as cluster:
address = cluster.scheduler_address
geoms = geom_from_library(
"ala_dipeptide_iso_b3lyp_631gd_10_images.trj")
for i, geom in enumerate(geoms):
calc = XTB(pal=1, calc_number=i)
geom.set_calculator(calc)
neb = NEB(geoms, scheduler=address)
max_cycles = 1
opt = SteepestDescent(neb, align=True, max_cycles=max_cycles)
opt.run()
assert opt.cur_cycle == (max_cycles - 1)
def test_bfgs_straight_neb():
"""Something is really really wrong here."""
kwargs = copy.copy(KWARGS)
kwargs["images"] = 10
convergence = {
"max_force_thresh": 5.0,
"rms_force_thresh": 1,
"max_step_thresh": 0.002,
"rms_step_thresh": 0.0006,
}
kwargs["convergence"] = convergence
neb = NEB(get_geoms(("A", "B")))
opt = run_cos_opt(neb, BFGS, **kwargs)
assert (opt.is_converged)
assert (opt.cur_cycle == 45)
return opt
def test_diels_alder_neb(opt_cls):
geoms = geom_from_library("diels_alder_interpolated.trj")
for i, geom in enumerate(geoms):
calc_kwargs = {
"basis": "sto3g",
"pal": 2,
"calc_number": i,
}
calc = PySCF(**calc_kwargs)
geom.set_calculator(calc)
neb = NEB(geoms)
opt_kwargs = {
"dump": True,
"align": True,
"max_cycles": 15,
}
opt = opt_cls(neb, **opt_kwargs)
opt.run()
def test_run_tsopt_from_cos(tsopt_key, tsopt_kwargs):
geoms = geom_from_library("ala_dipeptide_iso_b3lyp_631gd_10_images.trj")
orca_kwargs = {
"keywords": "b3lyp 6-31G* rijcosx",
"pal": 2,
"mem": 2000,
"charge": 0,
"mult": 1,
}
calc_number = 0
def calc_getter():
nonlocal calc_number
calc = ORCA(**orca_kwargs, calc_number=calc_number)
calc_number += 1
return calc
for i, geom in enumerate(geoms):
geom.set_calculator(calc_getter())
cos = NEB(geoms)
# We don't actually need to run an optimization step.
# When calling 'get_hei_index()' in the run_tsopt... function energy
# calculations will be done.
# opt_kwargs = {
# "max_cycles": 1,
# }
# opt = SteepestDescent(cos, **opt_kwargs)
# opt.run()
tsopt_kwargs_ = {
"trust_max": 0.3,
"thresh": "gau_loose",
"overachieve_factor": 1,
# "hessian_recalc": 10,
# "do_hess": False,
}
tsopt_kwargs_.update(tsopt_kwargs)
run_tsopt_from_cos(cos, tsopt_key, tsopt_kwargs_, calc_getter)
def test_steepest_descent_straight_neb():
"""Something is really really wrong here."""
kwargs = copy.copy(KWARGS)
kwargs["images"] = 10
kwargs["max_cycles"] = 100
convergence = {
"max_force_thresh": 1.16,
"rms_force_thresh": 0.27,
"max_step_thresh": 0.021,
"rms_step_thresh": 0.005,
}
kwargs["convergence"] = convergence
neb = NEB(get_geoms(("A", "B")))
opt = run_cos_opt(neb, SteepestDescent, **kwargs)
assert (opt.is_converged)
assert (opt.cur_cycle == 62)
return opt
def run_distributed(scheduler=None):
init_logging(THIS_DIR, scheduler)
atoms = ("H", "H")
geoms = list()
for i in range(7):
bond_length = 0.8 + i * 0.2
print(f"{i}: {bond_length:.02f}")
coords = np.array((0., 0., 0., 0., 0., bond_length))
geom = Geometry(atoms, coords)
# def2-TZVP / TDDFT
td_kwargs = {
"keywords": "BP86 def2-TZVP",
"charge": 0,
"mult": 1,
"calc_number": i,
"blocks": "%tddft nroots 2 iroot 1 end",
#"track": True,
"out_dir": THIS_DIR,
}
# def2-SV(P) / Ground state
kwargs = {
"keywords": "BP86 def2-SV(P)",
"charge": 0,
"mult": 1,
"calc_number": i,
"out_dir": THIS_DIR,
}
orca = ORCA(**td_kwargs)
geom.set_calculator(orca)
geoms.append(geom)
neb_kwargs = {
"dask_cluster": scheduler,
}
neb = NEB(geoms, **neb_kwargs)
forces = neb.forces
for f in forces.reshape(-1, 6):
print(f, f"{np.linalg.norm(f):.2f}")
for geom in neb.images:
print(geom.calculator.wfow)
def interpolate(self, initial_geom, final_geom):
# Do an initial linear interpolation to generate all geometries/images
# that will be refined later by IDPP interpolation.
linear_interpol = super().interpolate(initial_geom, final_geom)
idpp_geoms = [initial_geom] + linear_interpol + [final_geom]
align_geoms(idpp_geoms)
# Interestingly IDPP calculations work much better when done
# in Angstroem instead of in Bohr.
for geom in idpp_geoms:
geom.coords *= BOHR2ANG
# We want to interpolate between these two condensed distance matrices
initial_pd = pdist(initial_geom.coords3d)
final_pd = pdist(final_geom.coords3d)
steps = 1 + self.between
pd_diff = (final_pd - initial_pd) / steps
for i, geom in enumerate(idpp_geoms):
geom.set_calculator(IDPPCalculator(initial_pd + i * pd_diff))
neb = NEB(idpp_geoms, fix_ends=True)
opt_kwargs = {
"max_cycles": 1000,
"rms_force": 1e-2,
"align": False,
"check_coord_diffs": False,
}
opt = FIRE(neb, **opt_kwargs)
opt.run()
for geom in idpp_geoms:
# Delete IDPP calculator, energies and forces
geom.clear()
geom.coords *= ANG2BOHR
interpolated_geoms = idpp_geoms[1:-1]
return interpolated_geoms
def test_double_damped_neb(opt_cls, _opt_kwargs, ref_cycle, this_dir):
geoms = geom_loader(this_dir / "neb_input.trj")
for i, geom in enumerate(geoms):
calc_kwargs = {
"pal": 2,
"calc_number": i,
"charge": 0,
"mult": 1,
}
calc = XTB(**calc_kwargs)
geom.set_calculator(calc)
cos = NEB(geoms)
opt_kwargs = {
"max_step": 0.1,
"rms_force": 0.005,
"rms_force_only": True,
}
opt_kwargs.update(_opt_kwargs)
opt = opt_cls(cos, **opt_kwargs)
opt.run()
def prepare_opt(idpp=True):
path = Path(os.path.dirname(os.path.abspath(__file__)))
fns = ("hcn.xyz", "hcn_iso_ts.xyz", "nhc.xyz")
geoms = [geom_from_library(fn) for fn in fns]
calc_kwargs = {
"charge": 0,
"mult": 1,
}
cos_kwargs = {
#"parallel": 4,
#"fix_ends": True,
}
if idpp:
geoms = idpp_interpolate(geoms, 5)
neb = NEB(geoms, **cos_kwargs)
else:
neb = NEB(geoms, **cos_kwargs)
neb.interpolate(5)
for i, image in enumerate(neb.images):
image.set_calculator(XTB(calc_number=i, **calc_kwargs))
return neb
def get_neb():
geoms = get_geoms()
for g in geoms:
g.set_calculator(XTB())
neb = NEB(geoms)
return neb
def test_fire():
geoms, kwargs = get_geoms()
neb = NEB(geoms)
opt = run_cos_opt(neb, FIRE, **kwargs)
def test_bfgs():
geoms, kwargs = get_geoms()
neb = NEB(geoms)
opt = run_cos_opt(neb, BFGS, **kwargs)
