def main(pdb_path, splitAt, work_dir): monomers = create_monomers(pdb_path, splitAt, work_dir) settings = Settings() settings.basis = "DZP" # settings.functional = "CAMY-B3LYP" settings.specific.adf.basis.core = "None" settings.specific.adf.symmetry = "Nosym" settings.specific.adf.xc.hybrid = "CAMY-B3LYP" settings.specific.adf.xc.xcfun = "" fde_settings = Settings() # fde_settings.functional = "camy-b3lyp" fde_settings.specific.adf.xc.hybrid = "CAMY-B3LYP" fde_settings.specific.adf.xc.xcfun = "" fde_settings.basis = "DZP" fde_settings.specific.adf.symmetry = "Nosym" fde_settings.specific.adf.fde.PW91k = "" fde_settings.specific.adf.fde.fullgrid = "" fde_settings.specific.adf.allow = "Partialsuperfrags" fde_settings.specific.adf.fde.GGAPOTXFD = "Becke" fde_settings.specific.adf.fde.GGAPOTCFD = "LYP" # Read input from molfiles jobs = chain(*list( map(lambda xs: create_jobs(settings, fde_settings, *xs), enumerate(monomers)))) run(gather(*jobs), n_processes=2)
def main(file_xyz, cell, restart, basis, basis_folder): # Define which systems need to be calculated system = Molecule(file_xyz) # Set path for basis set basisCP2K = join(basis_folder, "BASIS_MOLOPT") potCP2K = join(basis_folder, "GTH_POTENTIALS") # Settings specifics s = templates.geometry s.basis = basis s.potential = "GTH-PBE" s.cell_parameters = cell s.specific.cp2k.force_eval.dft.basis_set_file_name = basisCP2K s.specific.cp2k.force_eval.dft.potential_file_name = potCP2K s.specific.cp2k.force_eval.dft.uks = '' s.specific.cp2k.force_eval.dft.charge = '1' s.specific.cp2k.force_eval.dft.multiplicity = '2' s.specific.cp2k.force_eval.dft.wfn_restart_file_name = '{}'.format(restart) # ======================= # Compute OPT files with CP2k # ======================= result = run(cp2k(s, system)) # ====================== # Output the results # ====================== print(result.energy)
def test_freq(): """ Do some constraint optimizations then launch a freq calc. """ mol = Molecule("test/test_files/ethene.xyz", "xyz") geo_opt = dftb(templates.geometry, mol) freq_calc = dftb(templates.freq, geo_opt.molecule, job_name="freq") r = run(freq_calc) assert int(r.frequencies[0]) == 831 assert len(r.frequencies) == 12
def test_adf_props(): """ Get properties from ADF freq calc """ mol = rdkitTools.smiles2rdkit('F[H]') result = run(adf(templates.freq, mol, job_name='adf_FH')) expected_energy = -0.30 assert abs(result.energy - expected_energy) < 0.01 assert len(result.dipole) == 3 expected_frequency = 3359.23 assert abs(result.frequencies[1] - expected_frequency) < 0.01 assert len(result.charges) == 2 assert abs(result.charges[0] + result.charges[1]) < 1e-6
def test_dftb_props(): """ Get properties from DFTB freq calc """ mol = rdkitTools.smiles2rdkit('F[H]') result = run(dftb(templates.freq, mol, job_name='dftb_FH')) expected_energy = -4.76 assert abs(result.energy - expected_energy) < 0.01 assert len(result.dipole) == 3 expected_frequency = 3293.85 assert abs(result.frequencies - expected_frequency) < 0.01 assert len(result.charges) == 2 assert abs(result.charges[0] + result.charges[1]) < 1e-6
def main(path_xyz): molecules = create_molecules(path_xyz) jobs = [create_dftb_job(m, i) for i, m in enumerate(molecules)] # Extract dipoles ds = gather(*[j.dipole for j in jobs]) # Extract charges cs = gather(*[j.charges for j in jobs]) # Run the workflow dipoles, charges = run(gather(ds, cs), folder='charges') # Print the dipoles np.savetxt('dipoles.txt', dipoles) save_coordinates_charges(molecules, charges)
def test_ADFGeometry_Constraint(): """ Test "freeze" and "selected_atoms" keywords for constrained geometry optimizations. """ an = plams.Molecule('test/test_files/an.xyz', 'xyz') # optimize only H atoms s = Settings() s.freeze = [1, 2, 3] result1 = adf(templates.geometry.overlay(s), an) geom1 = result1.molecule # optimize only H atoms s = Settings() s.selected_atoms = ['H'] result2 = adf(templates.geometry.overlay(s), an) geom2 = result2.molecule r = run(gather(geom1, geom2), n_processes=1) assert str(r[0]) == str(r[1])
def test_linear_ts(): """ compute a first approximation to the TS. """ # Read the Molecule from file cnc = Molecule('test/test_files/C-N-C.mol', 'mol') # User define Settings settings = Settings() settings.functional = "pbe" settings.basis = "SZ" settings.specific.dftb.dftb.scc constraint1 = Distance(0, 4) constraint2 = Distance(2, 3) # scan input pes = PES(cnc, constraints=[constraint1, constraint2], offset=[2.3, 2.3], get_current_values=False, nsteps=2, stepsize=[0.1, 0.1]) # returns a set of results object containing the output of # each point in the scan lt = pes.scan([dftb, adf], settings) # Gets the object presenting the molecule # with the maximum energy calculated from the scan apprTS = select_max(lt, "energy") # Run the TS optimization, using the default TS template ts = run(apprTS) expected_energy = -3.219708290363864 assert abs(ts.energy - expected_energy) < 0.02
def main(file_xyz, cell, restart, basis, basis_folder): """ Define which systems need to be calculated """ system = Molecule(file_xyz) # Set path for basis set basisCP2K = join(basis_folder, "BASIS_MOLOPT") potCP2K = join(basis_folder, "GTH_POTENTIALS") # Settings specifics s = templates.singlepoint del s.specific.cp2k.force_eval.dft.print.mo s.basis = basis s.potential = "GTH-PBE" s.cell_parameters = cell s.specific.cp2k.force_eval.dft.basis_set_file_name = basisCP2K s.specific.cp2k.force_eval.dft.potential_file_name = potCP2K s.specific.cp2k.force_eval.dft.print.pdos.nlumo = '1000' s.specific.cp2k.force_eval.dft.wfn_restart_file_name = '{}'.format(restart) s.specific.cp2k.force_eval.dft.scf.ot.minimizer = 'DIIS' s.specific.cp2k.force_eval.dft.scf.ot.n_diis = 7 s.specific.cp2k.force_eval.dft.scf.ot.preconditioner = 'FULL_SINGLE_INVERSE' s.specific.cp2k['global']['run_type'] = 'energy' # ======================= # Compute OPT files with CP2k # ======================= result = run(cp2k(s, system)) # ====================== # Output the results # ====================== print(result.energy)
plams.init() # User Defined imports from qmworks.packages.SCM import dftb, adf # from qmworks.components import adffragmentsjob rdmol = Chem.MolFromPDBFile('Dialanine.pdb') supermol = rdopp.add_prot_Hs(rdmol) # settings = Settings () # settings.functional = 'bp86' # # settings.basis = 'DZP' # settings.specific.adf.basis.core = 'Large' # supermolecule calculation # supermol_job = adf(templates.singlepoint.overlay(settings), supermol, job_name = 'supermol_singlepoint') supermol_job = dftb(templates.singlepoint, supermol, job_name = 'supermol_singlepoint') # supermol_dipole = supermol_results.get_dipole_vector() #frags,caps = rdkitTools.partition_protein(supermol, cap=None) frags, caps = rdopp.partition_protein(supermol, cap=None) # mfcc_job = mfcc(adf, frags, caps, settings) mfcc_job = mfcc(dftb, frags, caps) supermol_result, mfcc_result = run(gather(supermol_job, mfcc_job)) print(supermol_result.dipole) print(mfcc_result.dipole)
def workflow_oscillator_strength( package_name: str, project_name: str, package_args: Dict, guess_args: Dict = None, geometries: List = None, dictCGFs: Dict = None, enumerate_from: int = 0, calc_new_wf_guess_on_points: str = None, path_hdf5: str = None, package_config: Dict = None, work_dir: str = None, initial_states: Any = None, final_states: Any = None, traj_folders: List = None, hdf5_trans_mtx: str = None, nHOMO: int = None, couplings_range: Tuple = None, calculate_oscillator_every: int = 50, convolution: str = 'gaussian', broadening: float = 0.1, # eV energy_range: Tuple = None, # eV geometry_units='angstrom', **kwargs): """ Compute the oscillator strength :param package_name: Name of the package to run the QM simulations. :param project_name: Folder name where the computations are going to be stored. :param geometry:string containing the molecular geometry. :param package_args: Specific settings for the package :param guess_args: Specific settings for guess calculate with `package`. :type package_args: dict :param initial_states: List of the initial Electronic states. :type initial_states: [Int] :param final_states: List containing the sets of possible electronic states. :type final_states: [[Int]] :param calc_new_wf_guess_on_points: Points where the guess wave functions are calculated. :param package_config: Parameters required by the Package. :param convolution: gaussian | lorentzian :param calculate_oscillator_every: step to compute the oscillator strengths :returns: None """ # Start logging event file_log = '{}.log'.format(project_name) logging.basicConfig(filename=file_log, level=logging.DEBUG, format='%(levelname)s:%(message)s %(asctime)s\n', datefmt='%m/%d/%Y %I:%M:%S %p') # Point calculations Using CP2K mo_paths_hdf5 = calculate_mos(package_name, geometries, project_name, path_hdf5, traj_folders, package_args, guess_args, calc_new_wf_guess_on_points, enumerate_from, package_config=package_config) # geometries in atomic units molecules_au = [ change_mol_units(parse_string_xyz(gs)) for gs in geometries ] # Construct initial and final states ranges initial_states, final_states = build_transitions(initial_states, final_states, nHOMO) # Schedule the function the compute the Oscillator Strenghts scheduleOscillator = schedule(calcOscillatorStrenghts) oscillators = gather(*[ scheduleOscillator(i, project_name, mo_paths_hdf5, dictCGFs, mol, path_hdf5, hdf5_trans_mtx=hdf5_trans_mtx, initial_states=initial_states, final_states=final_states) for i, mol in enumerate(molecules_au) if i % calculate_oscillator_every == 0 ]) energies, promised_cross_section = create_promised_cross_section( oscillators, broadening, energy_range, convolution, calculate_oscillator_every) cross_section, data = run(gather(promised_cross_section, oscillators), folder=work_dir) # Transform the energy to nm^-1 energies_nm = energies * 1240 # Save cross section np.savetxt( 'cross_section_cm.txt', np.stack((energies, energies_nm, cross_section, cross_section * 1e16), axis=1), header= 'Energy[eV] Energy[nm^-1] photoabsorption_cross_section[cm^2] photoabsorption_cross_section[^2]' ) # molar extinction coefficients (e in M-1 cm-1) nA = physical_constants['Avogadro constant'][0] cte = np.log(10) * 1e3 / nA extinction_coefficients = cross_section / cte np.savetxt( 'molar_extinction_coefficients.txt', np.stack((energies, energies_nm, extinction_coefficients), axis=1), header='Energy[eV] Energy[nm^-1] Extinction_coefficients[M^-1 cm^-1]') print("Data: ", data) print("Calculation Done") # Write data in human readable format write_information(data) return data
def generate_pyxaid_hamiltonians(package_name: str, project_name: str, package_args: Dict, guess_args: Dict = None, geometries: List = None, dictCGFs: Dict = None, calc_new_wf_guess_on_points: str = None, path_hdf5: str = None, enumerate_from: int = 0, package_config: Dict = None, dt: float = 1, traj_folders: List = None, work_dir: str = None, basisname: str = None, hdf5_trans_mtx: str = None, nHOMO: int = None, couplings_range: Tuple = None, algorithm='levine', ignore_warnings=False, tracking=True) -> None: """ Use a md trajectory to generate the hamiltonian components to run PYXAID nonadiabatic molecular dynamics. :param package_name: Name of the package to run the QM simulations. :param project_name: Folder name where the computations are going to be stored. :param package_args: Specific Settings for the package that will compute the MOs. :param geometries: List of string cotaining the molecular geometries numerical results. :paramter dictCGFS: Dictionary from Atomic Label to basis set :param calc_new_wf_guess_on_points: Calculate a guess wave function either in the first point or on each point of the trajectory. :param path_hdf5: path to the HDF5 file were the data is going to be stored. :param enumerate_from: Number from where to start enumerating the folders create for each point in the MD. :param hdf5_trans_mtx: Path into the HDF5 file where the transformation matrix (from Cartesian to sphericals) is stored. :param dt: Time used in the dynamics (femtoseconds) :param package_config: Parameters required by the Package. :type package_config: Dict :param nHOMO: index of the H**O orbital. :param couplings_range: Range of MO use to compute the nonadiabatic coupling matrix. :returns: None """ # Start logging event file_log = '{}.log'.format(project_name) logging.basicConfig(filename=file_log, level=logging.DEBUG, format='%(levelname)s:%(message)s %(asctime)s\n', datefmt='%m/%d/%Y %I:%M:%S %p') # Log initial config information log_config(work_dir, path_hdf5, algorithm) # prepare Cp2k Jobs # Point calculations Using CP2K mo_paths_hdf5 = calculate_mos(package_name, geometries, project_name, path_hdf5, traj_folders, package_args, guess_args, calc_new_wf_guess_on_points, enumerate_from, package_config=package_config, ignore_warnings=ignore_warnings) # Overlap matrix at two different times promised_overlaps = calculate_overlap(project_name, path_hdf5, dictCGFs, geometries, mo_paths_hdf5, hdf5_trans_mtx, enumerate_from, nHOMO=nHOMO, couplings_range=couplings_range) # Calculate Non-Adiabatic Coupling schedule_couplings = schedule(lazy_couplings) promised_crossing_and_couplings = schedule_couplings(promised_overlaps, path_hdf5, project_name, enumerate_from, nHOMO, dt, tracking, algorithm=algorithm) # Write the results in PYXAID format path_hamiltonians = join(work_dir, 'hamiltonians') if not os.path.exists(path_hamiltonians): os.makedirs(path_hamiltonians) # Inplace scheduling of write_hamiltonians function. # Equivalent to add @schedule on top of the function schedule_write_ham = schedule(write_hamiltonians) # Number of matrix computed nPoints = len(geometries) - 2 # Write Hamilotians in PYXAID format promise_files = schedule_write_ham(path_hdf5, mo_paths_hdf5, promised_crossing_and_couplings, nPoints, path_dir_results=path_hamiltonians, enumerate_from=enumerate_from, nHOMO=nHOMO, couplings_range=couplings_range) run(promise_files, folder=work_dir) remove_folders(traj_folders)
# generate all jobs job_list = [] for name in reaction_names: reactant = calc_reactant(name) product, TS = calc_productAndTS(name) job_list.append(gather(reactant, product, TS)) # Need also the energy of ethene ethene = rdkitTools.smiles2plams('C=C') E_ethene_job = dftb(templates.geometry.overlay(settings), ethene, job_name="ethene").energy # Actual execution of the jobs E_ethene, results = run(gather(E_ethene_job, gather(*job_list)), n_processes=1) def bond_distance(r1, r2): return sqrt(sum((x - y)**2 for x, y in zip(r1, r2))) # extract table from results table = {} for reactant, product, TS in results: # Retrieve the molecular coordinates mol = TS.molecule d1 = bond_distance(mol.atoms[0].coords, mol.atoms[1].coords) d2 = bond_distance(mol.atoms[3].coords, mol.atoms[4].coords) Eact = (TS.energy - E_ethene - reactant.energy) * hartree2kcal
plams.init() hartree2kcal = 627.5095 def bond_distance(r1, r2): return sqrt(sum((x - y)**2 for x, y in zip(r1, r2))) startvalue = {'C': 2.1, 'N': 1.9, 'O': 1.8} settings = Settings() settings.specific.dftb.dftb.scc ethene = rdkitTools.smiles2plams('C=C') E_ethene = run(dftb(templates.geometry.overlay(settings), ethene)).energy molecules = set() result = {} for a1 in ('C', 'N', 'O'): for a2 in ('N', 'O', 'S'): for a3 in ('C', 'N', 'O'): # reactant smiles = 'C1' + a1 + a2 + a3 + 'C1' reverse = 'C1' + a3 + a2 + a1 + 'C1' if reverse in molecules: # skip duplicates continue molecules.add(smiles) print(smiles) product = rdkitTools.smiles2plams(smiles) E_product = dftb(templates.geometry.overlay(settings),
'nsteps': 6, 'start': [2.3, 2.3], 'stepsize': [0.1, 0.1] } } # returns a set of results object containing the output of # each point in the scan lt = PES_scan([dftb, adf], settings, cnc, scan) # Gets the object presenting the molecule # with the maximum energy calculated from the scan apprTS = select_max(lt, "energy") appr_hess = dftb(templates.freq.overlay(settings), apprTS.molecule) t = Settings() t.specific.adf.geometry.inithess = appr_hess.archive.path # Run the TS optimization with ADF, using initial hessian from DFTB freq calculation ts = run(adf(templates.ts.overlay(settings).overlay(t), appr_hess.molecule), n_processes=1) # Retrieve the molecular coordinates mol = ts.molecule r1 = mol.atoms[0].coords r2 = mol.atoms[4].coords print("TS Bond distance:", bond_distance(r1, r2)) print("TS Energy:", ts.energy)
reactant = calc_reactant(name) product, adf_freq = calc_productAndTS(name) job_list.append(gather(reactant, product, adf_freq)) # Need also the energy of ethene ethene = rdkitTools.smiles2rdkit('C=C') E_ethene_job = adf(templates.geometry.overlay(settings), ethene, job_name="ethene").energy # finalize and draw workflow wf = gather(E_ethene_job, gather(*job_list)) draw_workflow("wf.svg", wf._workflow) # Actual execution of the jobs E_ethene, results = run(wf, n_processes=2) def bond_distance(r1, r2): return sqrt(sum((x - y)**2 for x, y in zip(r1, r2))) # extract table from results table = {} for reactant, product, TS in results: # Retrieve the molecular coordinates mol = TS.molecule d1 = bond_distance(mol.atoms[0].coords, mol.atoms[1].coords) d2 = bond_distance(mol.atoms[3].coords, mol.atoms[4].coords) Eact = (TS.energy - E_ethene - reactant.energy) * hartree2kcal
t = Settings() t.specific.adf.geometry.inithess = DFTBfreq.kf.path TS = adf(templates.ts.overlay(settings).overlay(t), DFTBfreq.molecule, job_name=name + "_TS") # Perform a freq calculation TSfreq = adf(templates.freq.overlay(settings), TS.molecule, job_name=name + "_freq") # Add the jobs to the job list job_list.append(gather(r1job, r2job, pjob, TSfreq, TS.optcycles)) # Finalize and draw workflow wf = gather(*job_list) draw_workflow("wf.svg", wf._workflow) # Actual execution of the jobs results = run(wf, n_processes=1) # Extract table from results table = {} for r1result, r2result, presult, tsresult, optcycles in results: # Retrieve the molecular coordinates mol = tsresult.molecule d1 = bond1.get_current_value(mol) d2 = bond2.get_current_value(mol) Eact = (tsresult.energy - r1result.energy - r2result.energy) * hartree2kcal Ereact = (presult.energy - r1result.energy - r2result.energy) * hartree2kcal name = presult.molecule.properties.name smiles = presult.molecule.properties.smiles nnegfreq = sum([f < 0 for f in tsresult.frequencies]) table[name] = [smiles, Eact, Ereact, d1, d2, nnegfreq, optcycles]
HH = plams.Molecule("H_Mes2PCBH2_TS3series1.xyz") HH.guess_bonds() newmol = rdkitTools.apply_template(HH, template) # Change the 2 hydrogens to dummy atoms temp = rdkitTools.modify_atom(newmol, 47, '*') temp = rdkitTools.modify_atom(temp, 48, '*') # Put coordinates of dummy atoms to 0.0, this will force generating new # coordinates for the new atoms temp.atoms[47].move_to((0.0, 0.0, 0.0)) temp.atoms[48].move_to((0.0, 0.0, 0.0)) # Replace dummy atoms by new groups, generate coordinates only for new atoms job_list = [] for mod, smirks in list_of_modifications.items(): print(mod) temp2 = rdkitTools.apply_smirks(temp, smirks)[0] temp2 = rdkitTools.apply_smirks(temp2, smirks)[0] freeze = rdkitTools.gen_coords(temp2) # rdkitTools.write_molblock(temp2) # generate job s = Settings() s.freeze = [a + 1 for a in freeze] partial_geometry = adf(templates.geometry.overlay(s), temp2, job_name="partial_opt_" + mod) job_list.append( adf(templates.ts, partial_geometry.molecule, job_name="ts_" + mod)) results = run(gather(*job_list), n_processes=1)
def fun_ethylene(scratch_path): """ Test Ethylene singlw """ project_name = 'ethylene' # create Settings for the Cp2K Jobs s = Settings() s.basis = "DZVP-MOLOPT-SR-GTH" s.potential = "GTH-PBE" s.cell_parameters = [12.74] * 3 dft = s.specific.cp2k.force_eval.dft dft.scf.added_mos = 20 dft.scf.eps_scf = 1e-4 dft['print']['ao_matrices']['overlap'] = '' dft['print']['ao_matrices']['filename'] = join(scratch_path, 'overlap.out') # Copy the basis and potential to a tmp file shutil.copy('test/test_files/BASIS_MOLOPT', scratch_path) shutil.copy('test/test_files/GTH_POTENTIALS', scratch_path) # Cp2k configuration files basiscp2k = join(scratch_path, 'BASIS_MOLOPT') potcp2k = join(scratch_path, 'GTH_POTENTIALS') cp2k_config = {"basis": basiscp2k, "potential": potcp2k} # HDF5 path path_hdf5 = join(scratch_path, 'ethylene.hdf5') # all_geometries type :: [String] path_xyz = 'test/test_files/ethylene.xyz' geometries = split_file_geometries(path_xyz) # Input/Output Files file_xyz = join(scratch_path, 'coordinates.xyz') file_inp = join(scratch_path, 'ethylene.inp') file_out = join(scratch_path, 'ethylene.out') file_MO = join(scratch_path, 'mo_coeffs.out') files = JobFiles(file_xyz, file_inp, file_out, file_MO) schedule_job = schedule(prepare_job_cp2k) promise = schedule_job(geometries[0], files, s, scratch_path, project_name=project_name, hdf5_file=path_hdf5, wfn_restart_job=None, store_in_hdf5=True, nHOMOS=25, nLUMOS=25, package_config=cp2k_config) cp2k_result = run(promise) path_properties = cp2k_result.orbitals with h5py.File(path_hdf5) as f5: assert (all(p in f5 for p in path_properties))
def calculate_ETR( package_name: str, project_name: str, package_args: Dict, path_time_coeffs: str=None, geometries: List=None, initial_conditions: List=None, path_hdf5: str=None, basis_name: str=None, enumerate_from: int=0, package_config: Dict=None, calc_new_wf_guess_on_points: str=None, guess_args: Dict=None, work_dir: str=None, traj_folders: List=None, dictCGFs: Dict=None, orbitals_range: Tuple=None, pyxaid_HOMO: int=None, pyxaid_Nmin: int=None, pyxaid_Nmax: int=None, fragment_indices: None=List, dt: float=1, **kwargs): """ Use a md trajectory to calculate the Electron transfer rate. :param package_name: Name of the package to run the QM simulations. :param project_name: Folder name where the computations are going to be stored. :param package_args: Specific settings for the package. :param path_hdf5: Path to the HDF5 file that contains the numerical results. :param geometries: List of string cotaining the molecular geometries. :paramter dictCGFS: Dictionary from Atomic Label to basis set :type dictCGFS: Dict String [CGF], CGF = ([Primitives], AngularMomentum), Primitive = (Coefficient, Exponent) :param calc_new_wf_guess_on_points: number of Computations that used a previous calculation as guess for the wave function. :param nHOMO: index of the H**O orbital. :param couplings_range: Range of MO use to compute the nonadiabatic :param pyxaid_range: range of HOMOs and LUMOs used by pyxaid. :param enumerate_from: Number from where to start enumerating the folders create for each point in the MD. :param traj_folders: List of paths to where the CP2K MOs are printed. :param package_config: Parameters required by the Package. :param fragment_indices: indices of atoms belonging to a fragment. :param dt: integration time used in the molecular dynamics. :returns: None """ # Start logging event file_log = '{}.log'.format(project_name) logging.basicConfig(filename=file_log, level=logging.DEBUG, format='%(levelname)s:%(message)s %(asctime)s\n', datefmt='%m/%d/%Y %I:%M:%S %p') # prepare Cp2k Job point calculations Using CP2K mo_paths_hdf5 = calculate_mos( package_name, geometries, project_name, path_hdf5, traj_folders, package_args, guess_args, calc_new_wf_guess_on_points, enumerate_from, package_config=package_config) # geometries in atomic units molecules_au = [change_mol_units(parse_string_xyz(gs)) for gs in geometries] # Time-dependent coefficients time_depend_coeffs = read_time_dependent_coeffs(path_time_coeffs) msg = "Reading time_dependent coefficients from: {}".format(path_time_coeffs) logger.info(msg) # compute_overlaps_ET scheduled_overlaps = schedule(compute_overlaps_ET) fragment_overlaps = scheduled_overlaps( project_name, molecules_au, basis_name, path_hdf5, dictCGFs, mo_paths_hdf5, fragment_indices, enumerate_from, package_name) # Delta time in a.u. dt_au = dt * femtosec2au # Indices relation between the PYXAID active space and the orbitals # stored in the HDF5 map_index_pyxaid_hdf5 = create_map_index_pyxaid( orbitals_range, pyxaid_HOMO, pyxaid_Nmin, pyxaid_Nmax) # Number of ETR points calculated with the MD trajectory n_points = len(geometries) - 2 # Read the swap between Molecular orbitals obtained from a previous # Coupling calculation swaps = read_swaps(path_hdf5, project_name) # Electron transfer rate for each frame of the Molecular dynamics scheduled_photoexcitation = schedule(compute_photoexcitation) etrs = scheduled_photoexcitation( path_hdf5, time_depend_coeffs, fragment_overlaps, map_index_pyxaid_hdf5, swaps, n_points, dt_au) # Execute the workflow electronTransferRates, path_overlaps = run( gather(etrs, fragment_overlaps), folder=work_dir) for i, mtx in enumerate(electronTransferRates): write_ETR(mtx, dt, i) write_overlap_densities(path_hdf5, path_overlaps, dt)
plams.init() # Read the Molecule from file m_h2o_1 = Molecule('FDE-H2O-1.xyz') m_h2o_2 = Molecule('FDE-H2O-2.xyz') m_mol = Molecule('FDE-mol.xyz') m_tot = m_mol + m_h2o_1 + m_h2o_2 print(m_tot) settings = Settings() settings.basis = 'SZ' settings.specific.adf.nosymfit = '' # Prepare first water molecule r_h2o_1 = adf(templates.singlepoint.overlay(settings), m_h2o_1, job_name="h2o_1") # Prepare second water molecule r_h2o_2 = adf(templates.singlepoint.overlay(settings), m_h2o_2, job_name="h2o_2") frozen_frags = [Fragment(r_h2o_1, [m_h2o_1]), Fragment(r_h2o_2, [m_h2o_2])] fde_res = run(fragmentsjob(settings, m_mol, *frozen_frags)) print(fde_res.dipole)
constraint2 = "dist 3 4" # scan input scan = { 'constraint': [constraint1, constraint2], 'surface': { 'nsteps': 6, 'start': [2.3, 2.3], 'stepsize': [0.1, 0.1] } } # returns a set of results object containing the output of # each point in the scan lt = PES_scan([dftb, adf], settings, cnc, scan) # Gets the object presenting the molecule # with the maximum energy calculated from the scan apprTS = select_max(lt, "energy") # Run the TS optimization, using the default TS template ts = run(adf(templates.ts.overlay(settings), apprTS.molecule), n_processes=2) # Retrieve the molecular coordinates mol = ts.molecule r1 = mol.atoms[0].coords r2 = mol.atoms[4].coords print("TS Bond distance:", bond_distance(r1, r2)) print("TS Energy:", ts.energy)