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)