def MakesGauInputs(mol_file, dihed_atoms_file, w, num_conform=19): """ Creates Gaussian input files in its own folder for mol_file structues that freezes the central angle at iterations of 180/num_conform degrees. This function requires Gaussian output file of molecule in question and file with dihedral atoms to be in the current working directory. """ molecule_name = mol_file.split('/')[-1][:-12] mol_pymat = Molecule.from_file(mol_file) molecule = pmgmol_to_rdmol(mol_pymat)[0] with open(dihed_atoms_file, 'r') as fn: data = fn.readlines() dihedral1 = data[0].split(',')[0] dihedral2 = data[0].split(',')[1] d1atom1_num = int(dihedral1.split()[0]) d1atom2_num = int(dihedral1.split()[1]) d1atom3_num = int(dihedral1.split()[2]) d1atom4_num = int(dihedral1.split()[3]) phi = np.linspace(start=0, stop=180, num=num_conform) for P in phi: dir_name = "{}/{}_{:.0f}deg/".format(os.getcwd(), molecule_name, P) os.mkdir(dir_name) file_name = "{}/{}_{:.0f}deg".format(dir_name, molecule_name, P) SetDihedralDeg(molecule.GetConformer(), d1atom1_num, d1atom2_num, d1atom3_num, d1atom4_num, P) with open(dir_name + "temp.xyz", 'w+') as fout: fout.write(str(MolToXYZBlock(molecule))) mol = Molecule.from_file(dir_name + 'temp.xyz') os.remove(dir_name + 'temp.xyz') gau = GaussianInput(mol=mol, charge=0, spin_multiplicity=1, functional='uLC-wPBE', basis_set='cc-pVDZ', route_parameters={ "iop(3/107={}, 3/108={})".format(w, w): "", "opt": "modredundant" }, link0_parameters={ '%mem': '5GB', '%chk': '{}.chk'.format(file_name.split('/')[-1]) }) gjf_file = gau.write_file(dir_name + 'temp.gjf') with open(dir_name + 'temp.gjf') as temp: lines = temp.readlines() os.remove(dir_name + 'temp.gjf') with open(file_name + '.gjf', 'w') as gjf: gjf.writelines([item for item in lines[:-2]]) gjf.write("D * {} {} * F\n\n".format(d1atom2_num + 1, d1atom3_num + 1)) print( "Torsion Gaussian input files for {} finsihed!".format(molecule_name))
def setUpClass(cls): cls.pt_mol = Molecule.from_file( os.path.join(module_dir, "..", "..", "test_files", "pt_gs_wb97mv_tz_initial.xyz")) cls.pt_rot_90_mol = Molecule.from_file( os.path.join(module_dir, "..", "..", "test_files", "pt_rotated_90.0.xyz"))
def test_random_seed(self, water, ethanol): """ Confirm that seed = -1 generates random structures while seed = 1 is deterministic """ # deterministic output with tempfile.TemporaryDirectory() as scratch_dir: pw = PackmolWrapper( scratch_dir, molecules=[ { "name": "water", "number": 10, "coords": water }, { "name": "ethanol", "number": 20, "coords": ethanol }, ], seed=1, inputfile="input.in", outputfile="output.xyz", ) pw.make_packmol_input() pw.run_packmol() out1 = Molecule.from_file(os.path.join(scratch_dir, "output.xyz")) pw.run_packmol() out2 = Molecule.from_file(os.path.join(scratch_dir, "output.xyz")) assert np.array_equal(out1.cart_coords, out2.cart_coords) # randomly generated structures with tempfile.TemporaryDirectory() as scratch_dir: pw = PackmolWrapper( scratch_dir, molecules=[ { "name": "water", "number": 10, "coords": water }, { "name": "ethanol", "number": 20, "coords": ethanol }, ], seed=-1, inputfile="input.in", outputfile="output.xyz", ) pw.make_packmol_input() pw.run_packmol() out1 = Molecule.from_file(os.path.join(scratch_dir, "output.xyz")) pw.run_packmol() out2 = Molecule.from_file(os.path.join(scratch_dir, "output.xyz")) assert not np.array_equal(out1.cart_coords, out2.cart_coords)
def test_random_seed(self, water, ethanol): """ Confirm that seed = -1 generates random structures while seed = 1 is deterministic """ mm = MoleculeMatcher() # deterministic output with tempfile.TemporaryDirectory() as scratch_dir: pw = PackmolBoxGen( seed=1, inputfile="input.in", outputfile="output.xyz", ).get_input_set( # scratch_dir, molecules=[ { "name": "water", "number": 10, "coords": water }, { "name": "ethanol", "number": 20, "coords": ethanol }, ], ) pw.write_input(scratch_dir) pw.run(scratch_dir) out1 = Molecule.from_file(os.path.join(scratch_dir, "output.xyz")) pw.run(scratch_dir) out2 = Molecule.from_file(os.path.join(scratch_dir, "output.xyz")) assert mm.fit(out1, out2) # randomly generated structures with tempfile.TemporaryDirectory() as scratch_dir: pw = PackmolBoxGen( seed=-1, inputfile="input.in", outputfile="output.xyz", ).get_input_set(molecules=[ { "name": "water", "number": 10, "coords": water }, { "name": "ethanol", "number": 20, "coords": ethanol }, ], ) pw.write_input(scratch_dir) pw.run(scratch_dir) out1 = Molecule.from_file(os.path.join(scratch_dir, "output.xyz")) pw.run(scratch_dir) out2 = Molecule.from_file(os.path.join(scratch_dir, "output.xyz")) assert not mm.fit(out1, out2)
def setUpClass(cls): # head molecule cls.peo_head = Molecule.from_file( os.path.join(test_dir, "peo_head.xyz")) charges = [ -0.1187, 0.0861, 0.0861, 0.0861, -0.2792, -0.0326, 0.0861, 0.0861 ] cls.peo_head.add_site_property("charge", charges) s_head = 0 s_tail = 5 # chain molecule cls.peo_bulk = Molecule.from_file( os.path.join(test_dir, "peo_bulk.xyz")) charges = [-0.0326, 0.0861, 0.0861, -0.2792, -0.0326, 0.0861, 0.0861] cls.peo_bulk.add_site_property("charge", charges) head = 0 tail = 4 # terminal molecule cls.peo_tail = Molecule.from_file( os.path.join(test_dir, "peo_tail.xyz")) charges = [ -0.0326, 0.0861, 0.0861, -0.2792, -0.1187, 0.0861, 0.0861, 0.0861 ] cls.peo_tail.add_site_property("charge", charges) e_head = 0 e_tail = 4 cls.n_units = 25 link_distance = 1.5075 # create the polymer cls.peo_polymer = Polymer(cls.peo_head, s_head, s_tail, cls.peo_bulk, head, tail, cls.peo_tail, e_head, e_tail, cls.n_units, link_distance) # linear chain cls.peo_polymer_linear = Polymer(cls.peo_head, s_head, s_tail, cls.peo_bulk, head, tail, cls.peo_tail, e_head, e_tail, cls.n_units, link_distance, linear_chain=True)
def WriteXYZ(in_file, out_dir): """ Write xyz file. """ mol = Molecule.from_file(in_file) fout = os.path.join(out_dir, in_file.split('/')[-1]) mol.to(filename=fout)
def generate_gjf(in_fn, out_dir, functional='LC-wHPBE', basis_set='TZVP', charge=0, calculation='opt', omega=None, oldchk=None): """ Convert an individually inputted xyz file to a gjf Gaussian input file """ mol = Molecule.from_file(in_fn) mol.perturb(0.1) mol_name = in_fn.split('/')[-1][:14] link0_parameters = {'%mem': '5GB', '%chk': '{}.chk'.format(calculation)} route_parameters = { calculation: '', 'SCF': '(MaxCycle=250)', 'Int': '(Grid=Ultrafine)' } if calculation == 'tddft': route_parameters = {'TD(NStates=5, 50-50)': ''} if omega is not None: route_parameters["iop(3/107={}, 3/108={})".format(omega, omega)] = '' if oldchk: link0_parameters['%oldchk'] = '{}.chk'.format(oldchk) route_parameters['Geom'] = 'AllCheck' gau = GaussianInput(mol=mol, charge=charge, functional=functional, basis_set=basis_set, route_parameters=route_parameters, link0_parameters=link0_parameters) gjf_file = gau.write_file('{}/{}.gjf'.format(out_dir, calculation)) return gjf_file
def test_packmol_with_str(self): """ Test coords input as strings """ with tempfile.TemporaryDirectory() as scratch_dir: pw = PackmolBoxGen().get_input_set(molecules=[ { "name": "EMC", "number": 10, "coords": os.path.join(test_dir, "subdir with spaces", "EMC.xyz") }, { "name": "LiTFSi", "number": 20, "coords": os.path.join(test_dir, "LiTFSi.xyz") }, ], ) pw.write_input(scratch_dir) pw.run(scratch_dir) assert os.path.exists(os.path.join(scratch_dir, "packmol_out.xyz")) out = Molecule.from_file( os.path.join(scratch_dir, "packmol_out.xyz")) assert out.composition.num_atoms == 10 * 15 + 20 * 16
def test_isomorphic(self): ethylene = Molecule.from_file( os.path.join( PymatgenTest.TEST_FILES_DIR, "graphs/ethylene.xyz", )) # switch carbons ethylene[0], ethylene[1] = ethylene[1], ethylene[0] eth_copy = MoleculeGraph.with_edges( ethylene, { (0, 1): { "weight": 2 }, (1, 2): { "weight": 1 }, (1, 3): { "weight": 1 }, (0, 4): { "weight": 1 }, (0, 5): { "weight": 1 }, }, ) # If they are equal, they must also be isomorphic eth_copy = copy.deepcopy(self.ethylene) self.assertTrue(self.ethylene.isomorphic_to(eth_copy)) self.assertFalse(self.butadiene.isomorphic_to(self.ethylene))
def run_task(self, fw_spec): self["constituent_molecules"] self["mols_number"] input_filename = self["input_filename"] forcefield = self["forcefield"] topologies = self["topologies"] user_settings = self.get("user_settings", {}) data_filename = self.get("data_filename", user_settings.get("data_file", "lammps.data")) final_molecule = self["final_molecule"] # if the final molecule was generated using packmol if fw_spec.get("packed_mol", None): final_molecule = fw_spec["packed_mol"] elif isinstance(final_molecule, str): final_molecule = Molecule.from_file(final_molecule) # molecules, mols_number, final_molecule lammps_ff_data = LammpsData.from_ff_and_topologies( forcefield, topologies, self["box_size"]) lammps_input_set = LammpsInputSet.from_file( "ff-inputset", self["input_file"], user_settings=user_settings, lammps_data=lammps_ff_data, data_filename=data_filename, is_forcefield=True, ) lammps_input_set.write_input(input_filename, data_filename)
def test_parse_pass_rotate_write(self): input_file = "pt_gs_wb97mv_tz_initial.in" output_file = "pt_gs_wb97mv_tz_initial_1_job.out" calc_dir = os.path.join(module_dir, "..", "..", "test_files") p_task = QChemToDb(calc_dir=calc_dir, input_file=input_file, output_file=output_file, db_file=">>db_file<<") fw1 = Firework([p_task]) atom_indexes = [6, 8, 9, 10] angle = 90.0 rot_task = RotateTorsion(atom_indexes=atom_indexes, angle=angle) w_task = WriteInputFromIOSet(qchem_input_set="OptSet", write_to_dir=module_dir) fw2 = Firework([rot_task, w_task], parents=fw1) wf = Workflow([fw1, fw2]) self.lp.add_wf(wf) rapidfire( self.lp, fworker=FWorker(env={"db_file": os.path.join(db_dir, "db.json")})) test_mol = QCInput.from_file(os.path.join(module_dir, "mol.qin")).molecule act_mol = Molecule.from_file( os.path.join(module_dir, "..", "..", "test_files", "pt_rotated_90.0.xyz")) np.testing.assert_equal(act_mol.species, test_mol.species) np.testing.assert_allclose(act_mol.cart_coords, test_mol.cart_coords, atol=0.0001)
def test_packmol_with_path(self): """ Test coords input as Path. Use a subdirectory with spaces. """ p1 = Path(os.path.join(test_dir, "subdir with spaces", "EMC.xyz")) p2 = Path(os.path.join(test_dir, "LiTFSi.xyz")) with tempfile.TemporaryDirectory() as scratch_dir: pw = PackmolWrapper( scratch_dir, molecules=[ { "name": "EMC", "number": 10, "coords": p1 }, { "name": "LiTFSi", "number": 20, "coords": p2 }, ], ) pw.make_packmol_input() pw.run_packmol() assert os.path.exists(os.path.join(scratch_dir, "packmol_out.xyz")) out = Molecule.from_file( os.path.join(scratch_dir, "packmol_out.xyz")) assert out.composition.num_atoms == 10 * 15 + 20 * 16
def test_packmol_with_molecule(self, water, ethanol): """ Test coords input as Molecule """ with tempfile.TemporaryDirectory() as scratch_dir: pw = PackmolWrapper( scratch_dir, molecules=[ { "name": "water", "number": 10, "coords": water }, { "name": "ethanol", "number": 20, "coords": ethanol }, ], ) pw.make_packmol_input() pw.run_packmol() assert os.path.exists(os.path.join(scratch_dir, "packmol_out.xyz")) out = Molecule.from_file( os.path.join(scratch_dir, "packmol_out.xyz")) assert out.composition.num_atoms == 10 * 3 + 20 * 9
def get_structures(self): host_path = self.args["input"][0] guest_path = self.args["input"][1] host = Structure.from_file(host_path) guest = Molecule.from_file(guest_path) return host, guest
def example_opt_restart(orca_code, opt_calc_pk=None, submit=True): """Run simple DFT calculation""" # This line is needed for tests only if opt_calc_pk is None: opt_calc_pk = pytest.opt_calc_pk # pylint: disable=no-member # structure thisdir = os.path.dirname(os.path.realpath(__file__)) xyz_path = os.path.join(thisdir, 'h2co.xyz') structure = StructureData(pymatgen_molecule=Molecule.from_file(xyz_path)) # old gbw file retr_fldr = load_node(opt_calc_pk).outputs.retrieved gbw_file = SinglefileData( os.path.join(retr_fldr._repository._get_base_folder().abspath, 'aiida.gbw')) #pylint: disable=protected-access # parameters parameters = Dict( dict={ 'charge': 0, 'multiplicity': 1, 'input_blocks': { 'scf': { 'convergence': 'tight', 'moinp': '"aiida_old.gbw"', }, 'pal': { 'nproc': 2, }, }, 'input_keywords': ['B3LYP/G', 'def2-TZVP', 'Opt'], 'extra_input_keywords': ['MOREAD'], }) # Construct process builder builder = OrcaCalculation.get_builder() builder.structure = structure builder.parameters = parameters builder.code = orca_code builder.file = { 'gbw': gbw_file, } builder.metadata.options.resources = { 'num_machines': 1, 'num_mpiprocs_per_machine': 1, } builder.metadata.options.max_wallclock_seconds = 1 * 10 * 60 if submit: print('Testing Orca Opt Calculations...') res, pk = run_get_pk(builder) print('calculation pk: ', pk) print('SCF Energy is :', res['output_parameters'].dict['scfenergies']) else: builder.metadata.dry_run = True builder.metadata.store_provenance = False
def MakesGauInputs(fn,w): """ Convert an individually imputted xyz file to a gjf Gaussian input file """ mol = Molecule.from_file(fn) mol_name = fn.split('/')[-1][:-12] gau = GaussianInput(mol=mol,charge=0,spin_multiplicity=1,functional='uLC-wPBE',basis_set='cc-pVDZ', route_parameters={"iop(3/107={}, 3/108={})".format(w,w):"","opt":"modredundant"}, link0_parameters={'%mem':'5GB','%chk':'{}.chk'.format(mol_name)}) gjf_file = gau.write_file('{}.gjf'.format(fn.split('.')[0])) return gjf_file
def mol_object(mol_fn): """ Get pymatgen object in preparation for further processing Returns: A pymatgen object """ try: return Molecule.from_file(mol_fn) except FileNotFoundError: print("File does not exist: {}".format(mol_fn))
def set_mol(self, mol_file, nmol): ''' set molecule files and number of molecules # ---------- args mol_file (list): list of path for molecular files (.xyz, etc) one can also use pre-defined strings such as H2O, CH4, benzene, ... etc. see PyXtal document nmol (list): number of molecules # ---------- example # ------ 4 benzene molecules in unit cell mol_file = ['benzene'] nmol = [4] # ------ molecules you make (2 * mol_1 and 2 * mol_2) mol_file = ['./mol_1.xyz', './mol_2.xyz'] nmol = [2, 2] ''' # ---------- check args # ------ mol_file if type(mol_file) is not list: raise ValueError('mol_file must be list') for s in mol_file: if type(s) is not str: raise ValueError('elements in mol_file must be string') # ------ nmol if type(nmol) is not list: raise ValueError('nmol must be list') for i in nmol: if type(i) is not int: raise ValueError('elements in nmol must be int') # ------ mol_file and nmol if not len(mol_file) == len(nmol): raise ValueError('not len(mol_file) == len(nmol)') # ---------- mol_data = [] pyxtal_mol_data = Collection('molecules') pyxtal_mol_names = list(Collection('molecules')) for i, mf in enumerate(mol_file): if os.path.isfile(mf): mol = Molecule.from_file(mf) elif mf in pyxtal_mol_names: mol = pyxtal_mol_data[mf] else: raise ValueError('no molecular files') mol_data.append(mol) # ---------- self.xxx self.nmol = nmol self.mol_data = mol_data
def MakeJSON(mol_dir,omega_file,json_file): """ For a molecule rotation directory, mol_dir, this finds the energy, xyz, and degree of rotation and places those into json_file. """ mol_name = str(mol_dir.split('/')[-1]) energy = 0 mol_xyz = 0 try: # if 0 == 0: log_fn = [x for x in os.listdir(mol_dir) if x.endswith('opt_0.log')][0] log_path = os.path.join(mol_dir,log_fn) mol = GaussianOutput(log_path) if mol.properly_terminated: num_electrons = mol.electrons[0] eigens = list(mol.eigenvalues.values())[0] h**o = eigens[num_electrons - 1] * 27.2114 lumo = eigens[num_electrons] * 27.2114 homo_lumo_gap = lumo - h**o pymat_mol = Molecule.from_file(log_path) smi_mol = pmgmol_to_rdmol(pymat_mol)[1] with open(omega_file,'r') as fn: omega_data = fn.readlines()[-2].split()[1] omega = "0{}".format(omega_data.split('.')[1]) normal = 1 else: normal = 0 print("Error. wtuning for did not properly terminate for {}".format(mol_name)) except Exception as e: normal = 0 print("Error. Data NOT collected for {}. Energy calculations for dihedral rotations may not have finished!".format(mol_name)) print(e) if normal == 1: json_data = { "molecule_name" : mol_name, "smiles" : smi_mol, "tuned_omega" : omega, "h**o" : h**o, "lumo" : lumo, "homo_lumo_gap" : homo_lumo_gap } with open(json_file,'w+') as fn: json.dump(json_data, fn) print("Data collected for {}".format(mol_name)) else: pass try: json_file.close() omega_file.close() except: pass
def setUpClass(cls): # head molecule cls.peo_head = Molecule.from_file(os.path.join(test_dir, "peo_head.xyz")) charges = [-0.1187, 0.0861, 0.0861, 0.0861, -0.2792, -0.0326, 0.0861, 0.0861] cls.peo_head.add_site_property("charge", charges) s_head = 0 s_tail = 5 # chain molecule cls.peo_bulk = Molecule.from_file(os.path.join(test_dir, "peo_bulk.xyz")) charges = [-0.0326, 0.0861, 0.0861, -0.2792, -0.0326, 0.0861, 0.0861] cls.peo_bulk.add_site_property("charge", charges) head = 0 tail = 4 # terminal molecule cls.peo_tail = Molecule.from_file(os.path.join(test_dir, "peo_tail.xyz")) charges = [-0.0326, 0.0861, 0.0861, -0.2792, -0.1187, 0.0861, 0.0861, 0.0861] cls.peo_tail.add_site_property("charge", charges) e_head = 0 e_tail = 4 cls.n_units = 25 link_distance = 1.5075 # create the polymer cls.peo_polymer = Polymer(cls.peo_head, s_head, s_tail, cls.peo_bulk, head, tail, cls.peo_tail, e_head, e_tail, cls.n_units, link_distance) # linear chain cls.peo_polymer_linear = Polymer(cls.peo_head, s_head, s_tail, cls.peo_bulk, head, tail, cls.peo_tail, e_head, e_tail, cls.n_units, link_distance, linear_chain=True)
def test_no_opt_Fragmentation(self): db_file = os.path.join(db_dir, "db.json") mmdb = QChemCalcDb.from_db_file(db_file, admin=True) with open( os.path.join(module_dir, "..", "..", "test_files", "sb40.json")) as f: tmp = json.load(f) for entry in tmp: mmdb.insert(entry) with patch("atomate.qchem.firetasks.fragmenter.FWAction" ) as FWAction_patch: mock_FWAction = MagicMock() FWAction_patch.return_value = mock_FWAction mock_FWAction.as_dict.return_value = { "stored_data": {}, "exit": False, "update_spec": {}, "mod_spec": [], "additions": [], "detours": [], "defuse_children": False, "defuse_workflow": False, } # define starting molecule and workflow object initial_mol = Molecule.from_file( os.path.join(module_dir, "..", "..", "test_files", "top_11", "EC.xyz")) initial_mol.set_charge_and_spin(charge=-1) wf = get_fragmentation_wf( molecule=initial_mol, depth=1, pcm_dielectric=40.0, do_optimization=False, check_db=True, ) self.lp.add_wf(wf) rapidfire( self.lp, fworker=FWorker(env={ "max_cores": 24, "db_file": db_file }), pdb_on_exception=True, ) self.assertEqual(len(FWAction_patch.call_args[1]["additions"]), 0) mmdb.reset()
def setUpClass(cls) -> None: cls.ec = Molecule.from_file(filename=os.path.join(test_dir, "EC.xyz")) cls.emc = Molecule.from_file( filename=os.path.join(test_dir, "EMC.xyz")) cls.dec = Molecule.from_file( filename=os.path.join(test_dir, "DEC.xyz")) cls.pf6 = Molecule.from_file( filename=os.path.join(test_dir, "PF6.xyz")) cls.tfsi = Molecule.from_file( filename=os.path.join(test_dir, "TFSI.xyz")) cls.litfsi = Molecule.from_file( filename=os.path.join(test_dir, "LiTFSI.xyz")) cls.lipf6 = Molecule.from_file( filename=os.path.join(test_dir, "LiPF6.xyz"))
def example_opt(orca_code, submit=True): """Run simple DFT calculation""" # structure thisdir = os.path.dirname(os.path.realpath(__file__)) xyz_path = os.path.join(thisdir, 'h2co.xyz') structure = StructureData(pymatgen_molecule=Molecule.from_file(xyz_path)) # parameters parameters = Dict( dict={ 'charge': 0, 'multiplicity': 1, 'input_blocks': { 'scf': { 'convergence': 'tight', }, 'pal': { #Uncomment for parallel run. 'nproc': 2, } }, 'input_keywords': ['B3LYP/G', 'SV(P)', 'Opt'], 'extra_input_keywords': [], }) # Construct process builder builder = OrcaBaseWorkChain.get_builder() builder.orca.structure = structure builder.orca.parameters = parameters builder.orca.code = orca_code builder.orca.metadata.options.resources = { 'num_machines': 1, 'num_mpiprocs_per_machine': 1, } builder.orca.metadata.options.max_wallclock_seconds = 1 * 10 * 60 if submit: print('Testing Orca Opt Calculations...') res, pk = run_get_pk(builder) print('calculation pk: ', pk) print('SCF Energy is :', res['output_parameters'].dict['scfenergies']) pytest.opt_calc_pk = pk else: builder.metadata.dry_run = True builder.metadata.store_provenance = False
def XYZtoGJF(xyz_fn, out_dir, functional, basis_set, charge=0): """ Convert an individually imputted xyz file to a gjf Gaussian input file """ mol = Molecule.from_file(xyz_fn) mol_name = xyz_fn.split('/')[-1].split('.')[0] gau = GaussianInput(mol=mol, charge=charge, functional=functional, basis_set=basis_set, route_parameters={"opt": ""}, link0_parameters={ '%mem': '5GB', '%chk': '{}.chk'.format(mol_name) }) gjf_file = gau.write_file('{}/{}.gjf'.format(out_dir, mol_name)) return gjf_file
def MakeJSON(mol_dir, json_file): """ For a molecule rotation directory, mol_dir, this finds the energy, xyz, and degree of rotation and places those into json_file. """ mol_name = str(mol_dir.split('/')[-1]) degree = str((mol_name.split('_')[-1])[:-3]) energy = 0 mol_xyz = 0 try: for f in mol_dir: gen = [x for x in os.listdir(mol_dir) if x.endswith('.log')] for mol_file in gen: mol_file_path = os.path.join(mol_dir, mol_file) with open(mol_file_path) as fn: normal = 0 for line in fn: if re.search('Normal termination', line): normal = 1 if re.search('SCF Done', line): possible_E = line.split()[4] if normal == 1: energy = possible_E mol_pymat = Molecule.from_file(mol_file_path) mol_xyz = mol_pymat.to(fmt="xyz") except: print( "Error! Data NOT collected for {}. Energy calculations for dihedral rotations may not have finished!" .format(mol_name)) if energy == 0 or mol_xyz == 0: print( "Error! Data NOT collected for {}. Energy calculations for dihedral rotations may not have finished!" .format(mol_name)) else: print(degree) json_data = { "molecule_name": mol_name, "degree": degree, "xyz": mol_xyz, "energy (Hartrees)": energy } print(json_data) with open(json_file, 'w+') as fn: json.dump(json_data, fn) print("Data collected for {}".format(d))
def XYZtoGJF(fn): """ Convert an individually imputted xyz file to a gjf Gaussian input file """ mol = Molecule.from_file(fn) gau = GaussianInput(mol=mol, charge=0, spin_multiplicity=1, functional='PM6', basis_set='', route_parameters={'': ''}, link0_parameters={ '%mem': '5GB', '%nproc': '1', '%chk': '{}.chk'.format(fn.split('.')[0]) }) gjf_file = gau.write_file('{}.gjf'.format(fn.split('.')[0])) return gjf_file
def setUpClass(cls): ethanol_coords = [[0.00720, -0.56870, 0.00000], [-1.28540, 0.24990, 0.00000], [1.13040, 0.31470, 0.00000], [0.03920, -1.19720, 0.89000], [0.03920, -1.19720, -0.89000], [-1.31750, 0.87840, 0.89000], [-1.31750, 0.87840, -0.89000], [-2.14220, -0.42390, -0.00000], [1.98570, -0.13650, -0.00000]] water_coords = [[9.626, 6.787, 12.673], [9.626, 8.420, 12.673], [10.203, 7.604, 12.673]] cls.ethanol_atoms = ["C", "C", "O", "H", "H", "H", "H", "H", "H"] cls.water_atoms = ["H", "H", "O"] ethanol = Molecule(cls.ethanol_atoms, ethanol_coords) water = Molecule(cls.water_atoms, water_coords) cls.mols = [ethanol, water] cls.cocktail = Molecule.from_file( os.path.join(test_dir, "cocktail.xyz")) cls.packmol_config = [{"number": 1}, {"number": 15}]
def to_system_data(file_name, protect_layer=9): mol = Molecule.from_file(file_name) elem_mol = list(str(site.species.elements[0]) for site in mol.sites) elem_counter = Counter(elem_mol) atom_names = list(elem_counter.keys()) atom_numbs = list(elem_counter.values()) atom_types = [list(atom_names).index(e) for e in elem_mol] natoms = np.sum(atom_numbs) tmpcoord = np.copy(mol.cart_coords) system = {} system['atom_names'] = atom_names system['atom_numbs'] = atom_numbs system['atom_types'] = np.array(atom_types, dtype=int) # center = [c - h_cell_size for c in mol.center_of_mass] system['orig'] = np.array([0, 0, 0]) system['coords'] = [tmpcoord] system['cells'] = [10.0 * np.eye(3)] return system
def test_arbitrary_filenames(self, water, ethanol): """ Make sure custom input and output filenames work. Use a subdirectory with spaces. """ with tempfile.TemporaryDirectory() as scratch_dir: os.mkdir(os.path.join(scratch_dir, "subdirectory with spaces")) pw = PackmolBoxGen(inputfile="input.in", outputfile=Path("output.xyz"), stdoutfile=Path("stdout.txt")).get_input_set( molecules=[ { "name": "water", "number": 10, "coords": water }, { "name": "ethanol", "number": 20, "coords": ethanol }, ], ) pw.write_input( os.path.join(scratch_dir, "subdirectory with spaces"), ) assert os.path.exists( os.path.join(scratch_dir, "subdirectory with spaces", "input.in")) pw.run(os.path.join(scratch_dir, "subdirectory with spaces"), ) assert os.path.exists( os.path.join(scratch_dir, "subdirectory with spaces", "output.xyz")) assert os.path.exists( os.path.join(scratch_dir, "subdirectory with spaces", "stdout.txt")) out = Molecule.from_file( os.path.join(scratch_dir, "subdirectory with spaces", "output.xyz")) assert out.composition.num_atoms == 10 * 3 + 20 * 9
def test_no_opt_Fragmentation(self): db_file = os.path.join(db_dir, "db.json") mmdb = QChemCalcDb.from_db_file(db_file, admin=True) with open(os.path.join(module_dir, "..", "..", "test_files","sb40.json")) as f: tmp = json.load(f) for entry in tmp: mmdb.insert(entry) with patch("atomate.qchem.firetasks.fragmenter.FWAction") as FWAction_patch: mock_FWAction = MagicMock() FWAction_patch.return_value = mock_FWAction mock_FWAction.as_dict.return_value = {'stored_data': {}, 'exit': False, 'update_spec': {}, 'mod_spec': [], 'additions': [], 'detours': [], 'defuse_children': False, 'defuse_workflow': False} # define starting molecule and workflow object initial_mol = Molecule.from_file(os.path.join(module_dir, "..", "..", "test_files", "top_11", "EC.xyz")) initial_mol.set_charge_and_spin(charge=-1) wf = get_fragmentation_wf(molecule=initial_mol, depth=1, pcm_dielectric=40.0, do_optimization=False, check_db=True) self.lp.add_wf(wf) rapidfire( self.lp, fworker=FWorker(env={"max_cores": 24, "db_file": db_file}), pdb_on_exception=True) self.assertEqual(len(FWAction_patch.call_args[1]["additions"]), 0) mmdb.reset()
def load_molecule(filename="ethane.xyz"): path = os.path.join(STRUCTURES, filename) return Molecule.from_file(path)
test_dir = os.path.join( os.path.dirname(__file__), "..", "..", "test_files", "reaction_network_files", ) """ Create a reaction network for testing, based on H2O molecule. Species include H2, H2O, H, O, O2, OH, H3O, each at the -1, 0, and +1 charge states. """ # Make molecule objects H2O_mol = Molecule.from_file(os.path.join(test_dir, "H2O.xyz")) H2O_mol1 = copy.deepcopy(H2O_mol) H2O_mol_1 = copy.deepcopy(H2O_mol) H2O_mol1.set_charge_and_spin(charge=1) H2O_mol_1.set_charge_and_spin(charge=-1) H2_mol = Molecule.from_file(os.path.join(test_dir, "H2.xyz")) H2_mol1 = copy.deepcopy(H2_mol) H2_mol_1 = copy.deepcopy(H2_mol) H2_mol1.set_charge_and_spin(charge=1) H2_mol_1.set_charge_and_spin(charge=-1) O2_mol = Molecule.from_file(os.path.join(test_dir, "O2.xyz")) O2_mol1 = copy.deepcopy(O2_mol) O2_mol_1 = copy.deepcopy(O2_mol) O2_mol1.set_charge_and_spin(charge=1)
# coding: utf-8 from __future__ import division, print_function, unicode_literals, absolute_import from atomate.qchem.workflows.base.FF_then_fragment import get_wf_FF_then_fragment from fireworks.core.launchpad import LaunchPad from pymatgen.core import Molecule mol = Molecule.from_file("BF4-.xyz") wf = get_wf_FF_then_fragment(molecule=mol, max_cores=32) lp = LaunchPad.auto_load() lp.add_wf(wf)
""" remainder = {} count_dict = get_elements_count(structure) weights = get_weight(stoich) scaled_max = max([count_dict[ele]*weights[ele] for ele in stoich.keys() ]) #determine the scaled maximum neded while scaled_max % lcm_list(list(weights.values())): # increase scaled max until it can accomodate correct stoichiometry scaled_max = scaled_max + 1 for ele, count in count_dict.items(): remainder[ele] = int((scaled_max - count_dict[ele]*weights[ele]) / (weights[ele])) return remainder surf = Molecule.from_file('D:\\Users\\RyanTrottier\\Documents\\Scrap\\tmp.'+type) center_i = 787 center = surf[center_i] # pymatgen.core.sites.Site for radius in [3,4,5,6,8]: dr = 4 stoich = get_stoichiometry(surf) sites = [center] + [ x[0] for x in surf.get_neighbors(center, radius)] mol = Molecule.from_sites(sites) remainder = get_remainder(mol, stoich) i = 0 # going to iterate over all sites, starting with the closest add_sites = surf.get_neighbors_in_shell(center.coords, radius+dr, dr)