def get_irc_calc(self, ts=None, mem="5GB", nprocshared=20, scratch=".", method="m062x", basis="6-311+g(2df,2p)"): "A method to create the IRC calculator object" if ts is None: if self.ts is None: return None elif not isinstance(self.conformer, TS): return None else: ts = self.conformer ts.rmg_molecule.updateMultiplicity() label = ts.reaction_label.replace( "(", "left").replace(")", "right") + "_irc_" + str(ts.index) calc = ASEGaussian(mem=mem, nprocshared=nprocshared, label=label, scratch=scratch, method=method, basis=basis, extra="irc=(calcall)", multiplicity=ts.rmg_molecule.multiplicity) calc.atoms = ts.ase_molecule del calc.parameters['force'] return calc
def test_water(): from ase.calculators.gaussian import Gaussian from ase.atoms import Atoms from ase.optimize.lbfgs import LBFGS from ase.io import read # First test to make sure Gaussian works calc = Gaussian(xc='pbe', chk='water.chk', label='water') calc.clean() water = Atoms('OHH', positions=[(0, 0, 0), (1, 0, 0), (0, 1, 0)], calculator=calc) opt = LBFGS(water) opt.run(fmax=0.05) forces = water.get_forces() energy = water.get_potential_energy() positions = water.get_positions() # Then test the IO routines water2 = read('water.log') forces2 = water2.get_forces() energy2 = water2.get_potential_energy() positions2 = water2.get_positions() # Compare distances since positions are different in standard orientation. dist = water.get_all_distances() dist2 = read('water.log', index=-1).get_all_distances() assert abs(energy - energy2) < 1e-7 assert abs(forces - forces2).max() < 1e-9 assert abs(positions - positions2).max() < 1e-6 assert abs(dist - dist2).max() < 1e-6
def get_overall_calc(self, ts=None, direction="forward", settings=None, scratch=None): """ A method to create a calculator that optimizes the overall geometry of a `TS` object Parameters: - ts (TS): A `TS` object that you want to perform calculations on - direction (str): the forward or reverse direction of the `TS` object - settings (dict): a dictionary of settings containing method, basis, mem, nprocshared - scratch (str): a directory where you want log files to be written to Returns: - calc (ASEGaussian): an ASEGaussian calculator with all of the proper setting specified """ if settings is None: settings = self.settings if scratch is None: scratch = self.scratch method = settings["method"] basis = settings["basis"] mem = settings["mem"] nprocshared = settings["nprocshared"] assert direction.lower() in ["forward", "reverse"] assert isinstance(ts, TS), "A TS object was not provided..." ts.rmg_molecule.updateMultiplicity() label = ts.reaction_label + "_" + direction.lower() + "_" + str( ts.index) new_scratch = os.path.join(scratch, "ts", ts.reaction_label, "conformers") try: os.makedirs(new_scratch) except OSError: pass calc = ASEGaussian( mem=mem, nprocshared=nprocshared, label=label, scratch=new_scratch, method=method, basis=basis, extra= "opt=(ts,calcfc,noeigentest,maxcycles=900) freq scf=(maxcycle=900) IOP(7/33=1,2/16=3)", multiplicity=ts.rmg_molecule.multiplicity) calc.atoms = ts.ase_molecule del calc.parameters['force'] return calc
def write_gaussian(filename, atoms): """Writes a basic Gaussian input file""" # Since Gaussian prints the geometry directly into the input file, we'll just # the write_input method from the Gaussian calculator, and just use the # default settings calc = Gaussian() calc.initialize(atoms) calc.write_input(filename, atoms)
def get_rotor_calc(self, conformer=None, torsion=None, mem="5GB", nprocshared=20, scratch=".", method="m062x", basis="6-311+g(2df,2p)", steps=36, step_size=10.0): """ A method to create all of the calculators needed to perform hindered rotor calculations given a conformer and a torsion """ assert (torsion and (isinstance(torsion, Torsion)) ), "To create a rotor calculator, you must provide a Torsion object." if not conformer: if not self.conformer: return None conformer = self.conformer assert isinstance( conformer, Conformer), "A Conformer object was not provided..." string = "" for bond in conformer.bonds: i, j = bond.atom_indices string += "B {} {}\n".format(i + 1, j + 1) i, j, k, l = torsion.atom_indices string += "D {} {} {} {} S {} {}".format(i + 1, j + 1, k + 1, l + 1, steps, float(step_size)) if isinstance(conformer, TS): label = self.label + "_tor_{}_{}".format(j, k) elif isinstance(conformer, Conformer): label = Chem.rdinchi.InchiToInchiKey(Chem.MolToInchi( Chem.MolFromSmiles(conformer.smiles))).strip("-N") label += "_tor{}{}".format(j, k) label = conformer.smiles + "_tor_{}_{}".format(j, k) conformer.rmg_molecule.updateMultiplicity() mult = conformer.rmg_molecule.multiplicity calc = ASEGaussian(mem=mem, nprocshared=nprocshared, label=label, scratch=scratch, method=method, basis=basis, extra="Opt=(CalcFC,ModRedun)", multiplicity=mult, addsec=[string]) calc.atoms = conformer.ase_molecule del calc.parameters['force'] return calc
def get_center_calc(self): """ A method to create a calculator that optimizes the reaction center of a `TS` object Parameters: - ts (TS): A `TS` object that you want to perform calculations on - direction (str): the forward or reverse direction of the `TS` object - settings (dict): a dictionary of settings containing method, basis, mem, nprocshared - scratch (str): a directory where you want log files to be written to Returns: - calc (ASEGaussian): an ASEGaussian calculator with all of the proper setting specified """ assert self.conformer.direction.lower() in ["forward", "reverse"] assert isinstance(self.conformer, TS), "A TS object was not provided..." indicies = [] for i, atom in enumerate(self.conformer.rmg_molecule.atoms): if not (atom.label != ""): indicies.append(i) addsec = "" for combo in list(itertools.combinations(indicies, 2)): a, b = combo addsec += "{0} {1} F\n".format(a + 1, b + 1) self.conformer.rmg_molecule.updateMultiplicity() label = self.conformer.reaction_label + "_" + self.conformer.direction.lower( ) + "_center_" + str(self.conformer.index) new_scratch = os.path.join(self.directory, "ts", self.conformer.reaction_label, "conformers") try: os.makedirs(new_scratch) except OSError: pass ase_gaussian = ASEGaussian( mem=self.settings["mem"], nprocshared=self.settings["nprocshared"], label=label, scratch=new_scratch, method=self.settings["method"], basis=self.settings["basis"], extra= "Opt=(ts,calcfc,noeigentest,ModRedun,maxcycles=900) scf=(maxcycle=900)", multiplicity=self.conformer.rmg_molecule.multiplicity, addsec=[addsec[:-1]]) ase_gaussian.atoms = self.conformer.ase_molecule del ase_gaussian.parameters['force'] return ase_gaussian
def get_shell_calc(self): """ A method to create a calculator that optimizes the reaction shell of a `TS` object Parameters: - ts (TS): A `TS` object that you want to perform calculations on - direction (str): the forward or reverse direction of the `TS` object - settings (dict): a dictionary of settings containing method, basis, mem, nprocshared - directory (str): a directory where you want log files to be written to Returns: - calc (ASEGaussian): an ASEGaussian calculator with all of the proper setting specified """ assert isinstance(self.conformer, TS), "A TS object was not provided..." assert self.conformer.direction.lower() in ["forward", "reverse"] self.conformer.rmg_molecule.updateMultiplicity() label = self.conformer.reaction_label + "_" + self.conformer.direction.lower( ) + "_shell_" + str(self.conformer.index) new_scratch = os.path.join(self.directory, "ts", self.conformer.reaction_label, "conformers") try: os.makedirs(new_scratch) except OSError: pass ind1 = self.conformer.rmg_molecule.getLabeledAtom("*1").sortingLabel ind2 = self.conformer.rmg_molecule.getLabeledAtom("*2").sortingLabel ind3 = self.conformer.rmg_molecule.getLabeledAtom("*3").sortingLabel combos = "" combos += "{0} {1} F\n".format(ind1 + 1, ind2 + 1) combos += "{0} {1} F\n".format(ind2 + 1, ind3 + 1) combos += "{0} {1} {2} F".format(ind1 + 1, ind2 + 1, ind3 + 1) ase_gaussian = ASEGaussian( mem=self.settings["mem"], nprocshared=self.settings["nprocshared"], label=label, scratch=new_scratch, method=self.settings["method"], basis=self.settings["basis"], extra= "Opt=(ModRedun,Loose,maxcycles=900) Int(Grid=SG1) scf=(maxcycle=900)", multiplicity=self.conformer.rmg_molecule.multiplicity, addsec=[combos]) ase_gaussian.atoms = self.conformer.ase_molecule del ase_gaussian.parameters['force'] return ase_gaussian
def get_conformer_calc(self): """ A method that creates a calculator for a `Conformer` that will perform a geometry optimization Parameters: - conformer (Conformer): A `Conformer` object that you want to perform hindered rotor calculations on - torsion (Torsion): A `Torsion` object that you want to perform hindered rotor calculations about - settings (dict): a dictionary of settings containing method, basis, mem, nprocshared - scratch (str): a directory where you want log files to be written to - convergence (str): ['verytight','tight','' (default)], specifies the convergence criteria of the geometry optimization Returns: - calc (ASEGaussian): an ASEGaussian calculator with all of the proper setting specified """ if isinstance(self.conformer, TS): logging.info( "TS object provided, cannot obtain a species calculator for a TS" ) return None assert isinstance(self.conformer, Conformer), "A Conformer object was not provided..." self.conformer.rmg_molecule.updateMultiplicity() label = "{}_{}".format(self.conformer.smiles, self.conformer.index) new_scratch = os.path.join(self.directory, "species", self.conformer.smiles, "conformers") try: os.makedirs(new_scratch) except OSError: pass ase_gaussian = ASEGaussian( mem=self.settings["mem"], nprocshared=self.settings["nprocshared"], label=label, scratch=new_scratch, method=self.settings["method"], basis=self.settings["basis"], extra= "opt=(calcfc,maxcycles=900,{}) freq IOP(7/33=1,2/16=3) scf=(maxcycle=900)" .format(self.convergence), multiplicity=self.conformer.rmg_molecule.multiplicity) ase_gaussian.atoms = self.conformer.ase_molecule del ase_gaussian.parameters['force'] return ase_gaussian
def gaus(mol, lab, level): level = level.split('_') Trip = False sym = mol.get_chemical_symbols() is_O = len(sym) == 1 and sym[0] == 'O' is_OO = len(sym) == 2 and sym[0] == 'O' and sym[1] == 'O' if is_O or is_OO or Trip == True: mol.set_calculator( Gaussian( label=lab, maxiter=60, geometry='noautoz noautosym nocenter', xc='b3lyp', basis='6-31+G', task= 'energy ignore \nset dft:converged true \ntask dft gradient', mult=3)) else: atom_num = mol.get_atomic_numbers() s = sum(atom_num) if s % 2 == 0: mol.set_calculator( Gaussian( label=lab, maxiter=60, geometry='noautoz noautosym nocenter', xc='b3lyp', basis='6-31+G', task= 'energy ignore \nset dft:converged true \ntask dft gradient', mult=1)) else: mol.set_calculator( Gaussian( label=lab, maxiter=60, geometry='noautoz noautosym nocenter', xc='b3lyp', basis='6-31+G', mult=2, task= 'energy ignore \nset dft:converged true \ntask dft gradient' )) return mol
def reactants_or_products_calc(self, autotst_mol, mem="5GB", nprocshared=20, scratch=".", method="m062x", basis="6-311+g(2df,2p)"): "A method that creates a calculator for a reactant or product" autotst_mol.rmg_molecule.updateMultiplicity() # using this round about way of doing stuff because rmg's `toAugumentedInChIKey` method doesn't work on our cluster smiles = autotst_mol.rmg_molecule.toSMILES() label = Chem.rdinchi.InchiToInchiKey( Chem.MolToInchi(Chem.MolFromSmiles(smiles))).strip("-N") calc = Gaussian( mem=mem, nprocshared=nprocshared, label=label, scratch=scratch, method=method, basis=basis, extra="opt=(verytight,gdiis,maxcycle=1000) freq IOP(2/16=3)", multiplicity=autotst_mol.rmg_molecule.multiplicity) del calc.parameters['force'] return calc
def test_h2of(): with open('def2-svp.gbs', 'w') as bfile: bfile.write(basis) atoms = Atoms('OH2F', positions=[(-1.853788, -0.071113, 0.000000), (-1.892204, 0.888768, 0.000000), (-0.888854, -0.232973, 0.000000), (1.765870, 0.148285, 0.000000)]) label = 'h2of-anion' calc = Gaussian(charge=-1.0, basis='gen', method='B3LYP', basisfile='@def2-svp.gbs/N', label=label, ioplist=['6/80=1', '6/35=4000000'], density='current', addsec=['%s.wfx' % label] ) # FIXME: the "addsec" argument above is correctly incorporated into the # input file, but it doesn't appear to do anything to the calculation. # What is it for? What is it suppsoed to do? atoms.calc = calc atoms.get_potential_energy()
def get_center_calc(self, mem="5GB", nprocshared=20, scratch=".", method="m062x", basis="6-311+g(2df,2p)"): "A method to create the calculator to perform the reaction center opt" indicies = [] for i, atom in enumerate(self.reaction.ts.rmg_ts.atoms): if (atom.label == ""): indicies.append(i) combos = "" for combo in list(itertools.combinations(indicies, 2)): a, b = combo combos += "{0} {1} F\n".format(a+1, b+1) self.reaction.ts.rmg_ts.updateMultiplicity() label = self.reaction.label.replace( "(", "left").replace(")", "right") + "_center" calc = Gaussian(mem=mem, nprocshared=nprocshared, label=label, scratch=scratch, method=method, basis=basis, extra="opt=(ts,calcfc,noeigentest,ModRedun)", multiplicity=self.reaction.ts.rmg_ts.multiplicity, addsec=[combos[:-1]]) del calc.parameters['force'] return calc
def get_center_calc(self, ts=None, mem="5GB", nprocshared=20, scratch=".", method="m062x", basis="6-311+g(2df,2p)"): "A method to create a calculator that optimizes the reaction shell" if ts is None: if self.ts is None: return None elif not isinstance(self.conformer, TS): return None else: ts = self.conformer assert isinstance(ts, TS), "A TS object was not provided..." indicies = [] for i, atom in enumerate(ts.rmg_molecule.atoms): if not (atom.label != ""): indicies.append(i) combos = "" for combo in list(itertools.combinations(indicies, 2)): a, b = combo combos += "{0} {1} F\n".format(a + 1, b + 1) ts.rmg_molecule.updateMultiplicity() label = ts.reaction_label.replace( "(", "left").replace(")", "right") + "_center_" + str(ts.index) calc = ASEGaussian(mem=mem, nprocshared=nprocshared, label=label, scratch=scratch, method=method, basis=basis, extra="Opt=(ModRedun,Loose,maxcycles=900) Int(Grid=SG1)", multiplicity=ts.rmg_molecule.multiplicity, addsec=[combos[:-1]]) calc.atoms = ts.ase_molecule del calc.parameters['force'] return calc
def get_species_calc(self, conformer=None, mem="5GB", nprocshared=20, scratch=".", method="m062x", basis="6-311+g(2df,2p)"): "A method that creates a calculator for a reactant or product that will perform a geometry optimization" if not conformer: if not self.conformer: return None conformer = self.conformer if isinstance(conformer, TS): logging.info( "TS object provided, cannot obtain a species calculator for a TS") return None assert isinstance( conformer, Conformer), "A Conformer object was not provided..." conformer.rmg_molecule.updateMultiplicity() # using this round about way of doing stuff because rmg's # `toAugumentedInChIKey` method doesn't work on our cluster smiles = conformer.rmg_molecule.toSMILES() label = Chem.rdinchi.InchiToInchiKey(Chem.MolToInchi( Chem.MolFromSmiles(smiles))).strip("-N") + "_{}".format(conformer.index) calc = ASEGaussian( mem=mem, nprocshared=nprocshared, label=label, scratch=scratch, method=method, basis=basis, extra="opt=(calcfc,verytight,gdiis,maxcycles=900) freq IOP(2/16=3)", multiplicity=conformer.rmg_molecule.multiplicity) calc.atoms = conformer.ase_molecule del calc.parameters['force'] return calc
def get_calculator(self): # Explicitly set parameters that must for security reasons not be # taken from file: calc = Gaussian(atoms=self.atoms, command=None, restart=None, ignore_bad_restart_file=Calculator._deprecated, label='Gaussian', directory='.', **self.parameters) return calc
def get_irc_calc(self): """ A method to create a calculator that runs an IRC calculation the overall geometry of a `TS` object Parameters: - ts (TS): A `TS` object that you want to perform calculations on - direction (str): the forward or reverse direction of the `TS` object - settings (dict): a dictionary of settings containing method, basis, mem, nprocshared - scratch (str): a directory where you want log files to be written to Returns: - calc (ASEGaussian): an ASEGaussian calculator with all of the proper setting specified """ assert isinstance(self.conformer, TS), "A TS object was not provided..." self.conformer.rmg_molecule.updateMultiplicity() label = self.conformer.reaction_label + "_irc_" + self.conformer.direction + "_" + str( self.conformer.index) new_scratch = os.path.join(self.directory, "ts", self.conformer.reaction_label, "irc") try: os.makedirs(new_scratch) except OSError: pass ase_gaussian = ASEGaussian( mem=self.settings["mem"], nprocshared=self.settings["nprocshared"], label=label, scratch=new_scratch, method=self.settings["method"], basis=self.settings["basis"], extra="irc=(calcall)", multiplicity=self.conformer.rmg_molecule.multiplicity) ase_gaussian.atoms = self.conformer.ase_molecule del ase_gaussian.parameters['force'] return ase_gaussian
def get_atomization(method, basis): energies = {} atoms = cheminfo.MULTIPLICITY.keys() for atom in atoms: multiplicity = cheminfo.MULTIPLICITY[atom] label = "_tmp_atom_" + atom calculator = GaussianCalculator(method=method, basis=basis, multiplicity=multiplicity, label=label) del calculator.parameters['force'] atomobj = ase.Atoms(atom, calculator=calculator) calculator.write_input(atomobj) command = calculator.command command = command.replace("PREFIX", label) run_gaussian(command) if "G4" in method: pattern = method + " Enthalpy" line = read_line(label + ".log", pattern) line = line.split() value = line[2] else: line = read_line(label + ".log", "SCF Done:") line = line.split() value = line[4] value = float(value) energies[atom] = value print(atom, value) return energies
def get_overall_calc(self, ts=None, mem="5GB", nprocshared=20, scratch=".", method="m062x", basis="6-311+g(2df,2p)"): "A method to create a calculator that optimizes the reaction shell" if ts is None: if self.ts is None: return None elif not isinstance(self.conformer, TS): return None else: ts = self.conformer assert isinstance(ts, TS), "A TS object was not provided..." ts.rmg_molecule.updateMultiplicity() label = ts.reaction_label.replace( "(", "left").replace(")", "right") + "_" + str(ts.index) calc = ASEGaussian( mem=mem, nprocshared=nprocshared, label=label, scratch=scratch, method=method, basis=basis, extra="opt=(ts,calcfc,noeigentest,maxcycles=900) freq", multiplicity=ts.rmg_molecule.multiplicity) calc.atoms = ts.ase_molecule del calc.parameters['force'] return calc
def write_gaussian(ase_object, out_dir, **kwargs): """ Write a Gaussian input file based on an ase object. Params :: ase_object: ASE IO Object: ASE file containing molecule used as input for Gaussian input file out_dir: str: path of directory to write the Gaussian input file **kwargs: dict: additional arguments to modify behaviour of gaussian input Returns :: None """ # this is used to identify the header line and replace it HEADER_FLAG = 'HEADER_FLAG' # change directory to destination where input file to be saved original_dir = getcwd() os.chdir(out_dir) gaussian_settings = {'method': HEADER_FLAG, 'basis': '6-31g', 'Opt': 'Tight', 'Freq': 'DiagFull ', 'multiplicity': 1, 'charge': 0, 'mem': '50GB', 'nproc': 20 # ***20 for Farber and 36 for Caviness } gaussian_settings.update(kwargs) # input file created will be gaussian_input.com calc = Gaussian(**gaussian_settings, label='gaussian_input') ase_object.set_calculator(calc) calc.write_input(ase_object) # change back directories os.chdir(original_dir) format_root(header_flag=HEADER_FLAG, file_name=os.path.join(out_dir, 'gaussian_input.com'))
def calc_set_up(): methods = set(['LSDA','B3LYP','PBE', 'MPW1PW91', 'HF', 'MP2']) basis_sets = set(['STO-3G', '3-21G', '6-31G', '6-31+G*', '6-311G', 'cc-pVDZ', 'cc-pVTZ', 'cc-pVQZ', 'aug-cc-pVDZ', 'aug-cc-pVTZ', 'aug-cc-pVQZ']) calc_dir = input("Name folder in which to place calculations (if it doesn't exist within /calc/ it will be created there): ") proj_name = input("Name of calculation/project: ") # METHODS print("Available methods are:") for m in methods: print(m) method = '' while not (method in methods): method = input("Select method: ") if not (method in methods): print("method " + method + " doesn't exist, try gain") # BASIS SETS print("Available basis sets are:") for basis in basis_sets: print(basis) basis = '' while not (basis in basis_sets): basis = input("Select basis set: ") if not (basis in basis_sets): print("Basis set " + basis + " doesn't exist, try gain") # Returning ase.calculator object with specified settings # TODO - maybe return several calculators depending on what we need later? return Gaussian(mem='4GB', nprocshared='8', label='calc/' + calc_dir + "/" + proj_name, xc=method, basis=basis, scf=['tight','novaracc'], integral='noxctest', freq='' ), 'calc/' + calc_dir
def get_rotor_calcs(self, autotst_object, mem="5GB", nprocshared=20, scratch=".", method="m062x", basis="6-311+g(2df,2p)"): """ A method to create all of the calculators needed to perform hindered rotor calculations""" calculators = {} for torsion in autotst_object.torsions: string = "" for bond in autotst_object.bonds: i, j = bond.indices string += "B {} {}\n".format(i + 1, j + 1) i, j, k, l = torsion.indices string += "D {} {} {} {} S 36 10.0".format(i + 1, j + 1, k + 1, l + 1) if isinstance(autotst_object, AutoTST_Reaction): label = autotst_object.label + "_tor_{}_{}".format(j, k) mult = autotst_object.ts.rmg_ts.multiplicity elif isinstance(autotst_object, AutoTST_TS): label = autotst_object.label + "_tor_{}_{}".format(j, k) mult = autotst_object.rmg_ts.multiplicity elif isinstance(autotst_object, AutoTST_Molecule): smiles = autotst_object.rmg_molecule.toSMILES() label = Chem.rdinchi.InchiToInchiKey( Chem.MolToInchi(Chem.MolFromSmiles(smiles))).strip("-N") label += "_tor{}{}".format(j, k) mult = autotst_object.rmg_molecule.multiplicity calc = Gaussian(mem=mem, nprocshared=nprocshared, label=label, scratch=scratch, method=method, basis=basis, extra="Opt=(CalcFC,ModRedun)", multiplicity=mult, addsec=[string]) del calc.parameters['force'] calculators[(j, k)] = calc return calculators
def main(): arg = sys.argv # Basically, the entire CP2K input is passed in explicitly. # Disable ASE's input generation by setting everything to None. # ASE should only add the CELL and the COORD section. calc=Gaussian(method='M062x', basis='6-311++G(d,p)', nproc = int(arg[3]), charge = 0, force = 'force', chk = '3w.chk', label='3w') p1 = read(arg[1],index=0,format='xyz') #p1.set_cell([[20,0,0],[0,20,0],[0,0,20]],scale_atoms=False,fix=None) #p1.set_pbc((True, True, True)) p1.set_calculator(calc) p2 = read(arg[2],index=0,format='xyz') #p2.set_cell([[20,0,0],[0,20,0],[0,0,20]],scale_atoms=False,fix=None) #p2.set_pbc((True, True, True)) p2.set_calculator(calc) # MaxwellBoltzmannDistribution(slab_from_file, 0.5 * 300 * units.kB, force_temp=True) # energy_start = atoms.get_potential_energy() + atoms.get_kinetic_energy() # dyn = VelocityVerlet(slab_from_file, 0.5 * units.fs) #def print_md(): # energy = atoms.get_potential_energy() + atoms.get_kinetic_energy() # print("MD total-energy: %.10feV" % energy) #dyn.attach(print_md, interval=1) # dyn.run(20) nim = 9 # number of images, including end points band = neb.ssneb(p1, p2, numImages = nim, method = 'normal', ss=False) if len(arg)>4: restart = True else: restart = False # to restart, uncomment the following lines which read the previous optimized images into the band if restart: for i in range(1,nim-1): filename = str(i)+'.CON' b = read(filename,format='vasp') band.path[i].set_positions(b.get_positions()) band.path[i].set_cell(b.get_cell()) # opt = neb.qm_ssneb(band, maxmove =0.2, dt=0.05) opt = neb.fire_ssneb(band, maxmove =0.2, dtmax = 0.1, dt=0.1) opt.minimize(forceConverged=0.1, maxIterations = 1000)
def get_irc_calc(self, mem="5GB", nprocshared=20, scratch=".", method="m062x", basis="6-311+g(2df,2p)"): "A method to create the IRC calculator object" self.reaction.ts.rmg_ts.updateMultiplicity() label = self.reaction.label.replace( "(", "left").replace(")", "right") + "_irc" calc = Gaussian(mem=mem, nprocshared=nprocshared, label=label, scratch=scratch, method=method, basis=basis, extra="irc=(calcall)", multiplicity=self.reaction.ts.rmg_ts.multiplicity) del calc.parameters['force'] return calc
def get_overall_calc(self, mem="5GB", nprocshared=20, scratch=".", method="m062x", basis="6-311+g(2df,2p)"): "A method to create the calculator to perform the full TS optimization" self.reaction.ts.rmg_ts.updateMultiplicity() label = self.reaction.label.replace("(", "left").replace(")", "right") calc = Gaussian(mem=mem, nprocshared=nprocshared, label=label, scratch=scratch, method=method, basis=basis, extra="opt=(ts,calcfc,noeigentest) freq", multiplicity=self.reaction.ts.rmg_ts.multiplicity) del calc.parameters['force'] return calc
def vib(struct, proj_path): #struct.calc = Gaussian(label='calc/' + proj_name + '/freq', # freq='') print("\nBeginning calculation of IR frequencies...") struct.calc = Gaussian(mem='4GB', nprocshared='8', label=proj_path + '/vib', ) #struct.get_potential_energy() ir = Infrared(struct) ir.run() ir.write_spectra('ir_spectra.dat') spectrum = ir.get_spectrum() ir.clean() # to get rid of disturbing .pckl files cluttering the directory print("Calculation of vibrational frequencies completed!\nPrinting spectrum...") return struct, spectrum
def get_shell_calc(self, mem="5GB", nprocshared=20, scratch=".", method="m062x", basis="6-311+g(2df,2p)"): "A method to create a calculator that optimizes the reaction shell" indicies = [] for i, atom in enumerate(self.reaction.ts.rmg_ts.atoms): if not (atom.label == ""): indicies.append(i) combos = "" for combo in list(itertools.combinations(indicies, 2)): a, b = combo combos += "{0} {1} F\n".format(a + 1, b + 1) self.reaction.ts.rmg_ts.updateMultiplicity() label = self.reaction.label.replace("(", "left").replace( ")", "right") + "_shell" calc = Gaussian( mem=mem, nprocshared=nprocshared, label=label, scratch=scratch, method=method, basis=basis, extra="Opt=(ModRedun,Loose,maxcycle=1000) Int(Grid=SG1)", multiplicity=self.reaction.ts.rmg_ts.multiplicity, addsec=[combos[:-1]]) del calc.parameters['force'] return calc
from ase.test import NotAvailable from ase.calculators.gaussian import Gaussian if Gaussian().get_command() is None: raise NotAvailable('Gaussian required') from ase.atoms import Atoms from ase.optimize.lbfgs import LBFGS # First test to make sure Gaussian works calc = Gaussian(method='pbepbe', basis='sto-3g', force='force', nproc=1, chk='water.chk', label='water') calc.clean() water = Atoms('OHH', positions=[(0., 0. ,0. ), (1. ,0. ,0. ), (0. ,1. ,0. )], calculator=calc) opt = LBFGS(water) opt.run(fmax=0.05) forces = water.get_forces() energy = water.get_potential_energy() positions = water.get_positions() # Then test the IO routines from ase.io import read water2 = read('water/water.log') forces2 = water2.get_forces() energy2 = water2.get_potential_energy()
def write_input(self, atoms, properties=None, systems_changes=None): self.gaus_calc = Gaussian(label=self.label) self.gaus_calc.parameters.update(self.gausdict) self.ddmc_calc = dDMC(label=self.label) self.ddmc_calc.parameters.update(self.ddmcdict)
from math import pi import numpy as np import ase from ase import Atoms from ase.calculators.gaussian import Gaussian from ase.optimize import BFGS from ase.db import connect from ase.constraints import FixInternals label = '{label}' kwargs = {kwargs} Gaussian.command = '{qc_command} < PREFIX.com > PREFIX.log' calc = Gaussian(**kwargs) atom = {atom} geom = {geom} mol = Atoms(symbols=atom, positions=geom) mol.set_calculator(calc) try: e = mol.get_potential_energy( ) # use the Gaussian optimizer (task optimize) """ #read the geometry from the output file outfile = '{label}.log' with open(outfile) as f: lines = f.readlines()
from ase.calculators.gaussian import Gaussian from ase.atoms import Atoms from ase.optimize.lbfgs import LBFGS # First test to make sure Gaussian works calc = Gaussian(method='pbepbe', basis='sto-3g', force='force', nproc=1, chk='water.chk', label='water') calc.clean() water = Atoms('OHH', positions=[(0, 0, 0), (1, 0, 0), (0, 1, 0)], calculator=calc) opt = LBFGS(water) opt.run(fmax=0.05) forces = water.get_forces() energy = water.get_potential_energy() positions = water.get_positions() # Then test the IO routines from ase.io import read water2 = read('water.log') forces2 = water2.get_forces() energy2 = water2.get_potential_energy() positions2 = water2.get_positions() #compare distances since positions are different in standard orientation
from ase.test import cli, require from ase.db import connect from ase.io.jsonio import read_json from ase.calculators.gaussian import Gaussian require('gaussian') cli("""\ ase-build O | ase-run gaussian -d gaussian_cmdline.json && ase-build O2 | ase-run gaussian -d gaussian_cmdline.json""") c = connect('gaussian_cmdline.json') dct = read_json('gaussian_cmdline.json') for name in ['O2', 'O']: d = c.get([('name', '=', name)]) id = d.id e1 = d.energy e2 = c.get_atoms(id).get_potential_energy() e3 = Gaussian.read_atoms(name).get_potential_energy() e4 = dct[id]['energy'] assert e1 == e2 == e3 == e4 print(e1) ae = 2 * c.get('name=O').energy - c.get('name=O2').energy assert abs(ae - 1.060) < 1e-3