molSimplify 1.7.4__py3-none-any.whl

tests/test_io.py

@@ -0,0 +1,84 @@
+import numpy as np
+from molSimplify.Scripts.io import (lig_load,
+                                    core_load,
+                                    printgeoms,
+                                    getsubstrates,
+                                    readdict_sub,
+                                    )
+from importlib_resources import files as resource_files
+
+
+def test_lig_load(resource_path_root):
+    lig_file = str(resource_path_root / "inputs" / "io" / "acac.mol2")
+    mol, emsg = lig_load(lig_file)
+    # Assert that the error message is empty
+    assert not emsg
+    # Convert to mol3D after loading the OBmol
+    mol.convert2mol3D()
+    # Load the reference from the ligand folder
+    ref, _ = lig_load('acac')
+
+    assert mol.natoms == ref.natoms
+    assert all(mol.symvect() == ref.symvect())
+    print(mol.coordsvect())
+    print(ref.coordsvect())
+    np.testing.assert_allclose(mol.coordsvect(), ref.coordsvect())
+    assert mol.charge == ref.charge
+
+
+def test_core_load():
+    file = str(resource_files("molSimplify").joinpath("Cores/ferrcore.xyz"))
+    core, emsg = core_load(file)
+    # Assert that the error message is empty
+    assert not emsg
+    core.convert2mol3D()
+    assert core.make_formula(latex=False) == "Fe1F1C10H9"
+
+    file = str(resource_files("molSimplify").joinpath("Cores/ferrocene.mol"))
+    core, emsg = core_load(file)
+    # Assert that the error message is empty
+    assert not emsg
+    core.convert2mol3D()
+    assert core.make_formula(latex=False) == "Fe1C10H10"
+
+
+def test_printgeoms(capsys):
+    printgeoms()
+    captured = capsys.readouterr()
+
+    ref = (
+        "Coordination: 1, geometry: none,\t short name: no \n"
+        "Coordination: 2, geometry: linear,\t short name: li \n"
+        "Coordination: 3, geometry: trigonal_planar,\t short name: tpl \n"
+        "Coordination: 4, geometry: square_planar,\t short name: sqp \n"
+        "Coordination: 4, geometry: tetrahedral,\t short name: thd \n"
+        "Coordination: 5, geometry: square_pyramidal,\t short name: spy \n"
+        "Coordination: 5, geometry: trigonal_bipyramidal,\t short name: tbp \n"
+        "Coordination: 6, geometry: octahedral,\t short name: oct \n"
+        "Coordination: 6, geometry: trigonal_prismatic,\t short name: tpr \n"
+        "Coordination: 7, geometry: pentagonal_bipyramidal,\t short name: pbp \n"
+        "Coordination: 8, geometry: square_antiprismatic,\t short name: sqap \n"
+        "Coordination: 8, geometry: trigonal_dodecahedral,\t short name: tdhd \n\n"
+    )
+    assert captured.out == ref
+
+
+def test_readdict_sub():
+    file = resource_files("molSimplify").joinpath("Substrates/substrates.dict")
+    sub_dict = readdict_sub(file)
+    assert sub_dict["methane"] == ['methane.xyz', 'ch4', '1', ['inter'],
+                                   ['N'], ['0', '#', 'BDH', '=', '104.9(0.1)']]
+    assert sub_dict["ethane"] == ['ethane.xyz', 'c2h6', '2', ['inter'],
+                                  ['B'], ['0', '#', 'BDH', '=', '101.1(0.4)']]
+
+
+def test_getsubstrates():
+    subs = getsubstrates()
+    ref = (
+        "acetaldehyde acetylene benzene biphenyl bromobenzene cumene "
+        "cyclohexene dha diphenylmethane estrogen ethanal ethane ethene "
+        "ethylene fluorene formaldehyde formicacid iodobenzene methanal "
+        "methane methanoicacid methanol methylazide n-quinolinylbutyramidate "
+        "n2 phenyl propane propene propylene propyne tert-butane toluene triazole xanthene"
+        )
+    assert subs == ref

tests/test_jobgen.py

@@ -0,0 +1,84 @@
+from argparse import Namespace
+from molSimplify.Scripts.jobgen import sgejobgen, slurmjobgen
+
+
+def test_sgejobgen_default(tmpdir):
+    args = Namespace(jname=None, jid=1, wtime=None, memory=None,
+                     queue=None, qccode=None, cpus=None, gpus=None,
+                     joption=None, modules=None, jcommand=None)
+    sgejobgen(args, [str(tmpdir)])
+    with open(tmpdir / 'jobscript') as fin:
+        lines = fin.read()
+    lines_ref = ('#$ -S /bin/bash\n'
+                 '#$ -N job1\n'
+                 '#$ -R y\n'
+                 '#$ -cwd\n'
+                 '#$ -l h_rt=168:00:00\n'
+                 '#$ -l h_rss=8G\n'
+                 '#$ -q cpus\n'
+                 '#$ -l cpus=1\n'
+                 '#$ -pe smp 1\n'
+                 'export OMP_NUM_THREADS=1\n')
+    assert lines == lines_ref
+
+
+def test_sgejobgen(tmpdir):
+    args = Namespace(jname='test', jid=1, wtime='90', memory='4G',
+                     queue='gpusbig', qccode='terachem', cpus=None, gpus='2',
+                     joption=None, modules=['openmp'], jcommand=None)
+    sgejobgen(args, [str(tmpdir)])
+    with open(tmpdir / 'jobscript') as fin:
+        lines = fin.read()
+    lines_ref = ('#$ -S /bin/bash\n'
+                 '#$ -N test1\n'
+                 '#$ -R y\n'
+                 '#$ -cwd\n'
+                 '#$ -l h_rt=90:00:00\n'
+                 '#$ -l h_rss=4G\n'
+                 '#$ -q gpusbig\n'
+                 '#$ -l gpus=2\n'
+                 '#$ -pe smp 2\n'
+                 'module load openmp\n'
+                 'export OMP_NUM_THREADS=2\n'
+                 'terachem terachem_input > $SGE_O_WORKDIR/opttest.out\n\n'
+                 'sleep 30\n')
+    assert lines == lines_ref
+
+
+def test_slurmjobgen_default(tmpdir):
+    args = Namespace(jname=None, jid=1, wtime=None, memory=None,
+                     queue=None, qccode=None, joption=None, modules=None,
+                     jcommand=None)
+    slurmjobgen(args, [str(tmpdir)])
+    with open(tmpdir / 'jobscript') as fin:
+        lines = fin.read()
+    lines_ref = ('#!/bin/bash\n'
+                 '#SBATCH --job-name=job1\n'
+                 '#SBATCH --output=batch.log\n'
+                 '#SBATCH --export=ALL\n'
+                 '#SBATCH -t 168:00:00\n'
+                 '#SBATCH --mem==8G\n'
+                 '#SBATCH --partition=cpus\n'
+                 '#SBATCH --nodes=1\n'
+                 '#SBATCH --ntasks-per-node=1\n')
+    assert lines == lines_ref
+
+
+def test_slurmjobgen(tmpdir):
+    args = Namespace(jname='test', jid=1, wtime='90', memory='4G',
+                     queue='testqueue', qccode='qchem', joption=None,
+                     modules=None, jcommand=None)
+    slurmjobgen(args, [str(tmpdir)])
+    with open(tmpdir / 'jobscript') as fin:
+        lines = fin.read()
+    lines_ref = ('#!/bin/bash\n'
+                 '#SBATCH --job-name=test1\n'
+                 '#SBATCH --output=batch.log\n'
+                 '#SBATCH --export=ALL\n'
+                 '#SBATCH -t 90:00:00\n'
+                 '#SBATCH --mem=4G\n'
+                 '#SBATCH --partition=testqueue\n'
+                 '#SBATCH --nodes=1\n'
+                 '#SBATCH --ntasks-per-node=1\n'
+                 'qchem qch.inp 1 > qch.out\n')
+    assert lines == lines_ref

tests/test_joption_pythonic.py

@@ -0,0 +1,27 @@
+from molSimplify.Scripts.generator import startgen_pythonic
+
+
+def test_joption_pythonic(tmpdir, resource_path_root):
+    out_dir = "cr_thd_2_cl_4_s_1/cr_thd_2_cl_4_s_1_conf_1/jobscript"
+    input_dict_homo = {
+        '-core': "cr",
+        '-coord': str(4),
+        '-oxstate': str(2),
+        '-lig': str("cl"),
+        '-geometry': "thd",
+        '-ligocc': "4",
+        '-rundir': str(tmpdir),
+        '-runtyp': "minimize",
+        '-keepHs': "yes",
+        '-spin': str(1),
+        '-jname': "{}_{}_{}_{}_hs_{}".format("cr", "thd", 2, "cl", 0),
+        '-modules': "cuda,terachem",
+        '-joption': "-fin terachem_input, -fin *.xyz, -fout scr/"
+    }
+    startgen_pythonic(input_dict_homo, write=1)
+    with open(str(tmpdir) + "/" + out_dir, 'r') as f_in:
+        data1 = f_in.readlines()
+    with open(resource_path_root / "refs" / "joption_pythonic_jobscript", 'r') as f_in:
+        data2 = f_in.readlines()
+    for i, j in zip(data1, data2):
+        assert i == j

tests/test_ligand_assign.py

@@ -0,0 +1,58 @@
+from molSimplify.Classes.ligand import ligand_assign, ligand_breakdown
+from molSimplify.Classes.mol3D import mol3D
+
+
+def test_six_monodentate(resource_path_root):
+    xyz_file = (resource_path_root / "inputs" / "ligand_assign_consistent"
+                / "fe_water_ammonia_carbonyl_formaldehyde_hydrogensulfide_hydrocyanide.xyz")
+    mol = mol3D()
+    mol.readfromxyz(xyz_file)
+
+    liglist, ligdents, ligcons = ligand_breakdown(mol, BondedOct=True)
+    (ax_ligand_list, eq_ligand_list, ax_natoms_list, eq_natoms_list,
+     ax_con_int_list, eq_con_int_list, ax_con_list, eq_con_list,
+     built_ligand_list) = ligand_assign(mol, liglist, ligdents, ligcons)
+    # Expecting:
+    # ax_ligands: ['water', 'carbonyl']
+    # eq_ligands: ['hydrogensulfide', 'ammonia', 'hydrocyanide', 'formaldehyde']
+
+    ax_formulas = [lig.mol.make_formula(latex=False) for lig in ax_ligand_list]
+    assert ax_formulas == ['S1H2', 'N1C1H1']
+    eq_formulas = [lig.mol.make_formula(latex=False) for lig in eq_ligand_list]
+    assert eq_formulas == ['O1H2', 'N1H3', 'O1C1', 'O1C1H2']
+
+    assert ax_natoms_list == [3, 3]
+    assert eq_natoms_list == [3, 4, 2, 4]
+
+    assert ax_con_int_list == [[0], [1]]
+    assert eq_con_int_list == [[0], [0], [0], [1]]
+
+    assert ax_con_list == [[14], [18]]
+    assert eq_con_list == [[1], [4], [8], [11]]
+
+
+def test_triple_bidentate(resource_path_root):
+    xyz_file = (resource_path_root / "inputs" / "ligand_assign_consistent"
+                / "fe_acac_bipy_bipy.xyz")
+    mol = mol3D()
+    mol.readfromxyz(xyz_file)
+
+    liglist, ligdents, ligcons = ligand_breakdown(mol, BondedOct=True)
+    (ax_ligand_list, eq_ligand_list, ax_natoms_list, eq_natoms_list,
+     ax_con_int_list, eq_con_int_list, ax_con_list, eq_con_list,
+     built_ligand_list) = ligand_assign(mol, liglist, ligdents, ligcons)
+
+    print(ax_ligand_list, eq_ligand_list)
+    ax_formulas = [lig.mol.make_formula(latex=False) for lig in ax_ligand_list]
+    assert ax_formulas == ['O2C5H7']
+    eq_formulas = [lig.mol.make_formula(latex=False) for lig in eq_ligand_list]
+    assert eq_formulas == ['N2C10H8', 'N2C10H8']
+
+    assert ax_natoms_list == [14]
+    assert eq_natoms_list == [20, 20]
+
+    assert ax_con_int_list == [[0, 5]]
+    assert eq_con_int_list == [[0, 1], [0, 1]]
+
+    assert ax_con_list == [[1, 6]]
+    assert eq_con_list == [[15, 16], [35, 36]]

tests/test_ligand_assign_consistent.py

@@ -0,0 +1,60 @@
+from molSimplify.Classes.ligand import ligand_assign_consistent, ligand_breakdown
+from molSimplify.Classes.mol3D import mol3D
+
+
+def test_six_monodentate(resource_path_root):
+    xyz_file = (resource_path_root / "inputs" / "ligand_assign_consistent"
+                / "fe_water_ammonia_carbonyl_formaldehyde_hydrogensulfide_hydrocyanide.xyz")
+    mol = mol3D()
+    mol.readfromxyz(xyz_file)
+
+    liglist, ligdents, ligcons = ligand_breakdown(mol, BondedOct=True)
+    (ax_ligand_list, eq_ligand_list, ax_natoms_list, eq_natoms_list,
+     ax_con_int_list, eq_con_int_list, ax_con_list, eq_con_list,
+     built_ligand_list) = ligand_assign_consistent(mol, liglist, ligdents,
+                                                   ligcons)
+    # Expecting:
+    # ax_ligands: ['water', 'carbonyl']
+    # eq_ligands: ['hydrogensulfide', 'ammonia', 'hydrocyanide', 'formaldehyde']
+
+    ax_formulas = [lig.mol.make_formula(latex=False) for lig in ax_ligand_list]
+    assert ax_formulas == ['O1H2', 'O1C1']
+    eq_formulas = [lig.mol.make_formula(latex=False) for lig in eq_ligand_list]
+    assert eq_formulas == ['S1H2', 'N1H3', 'N1C1H1', 'O1C1H2']
+
+    assert ax_natoms_list == [3, 2]
+    assert eq_natoms_list == [3, 4, 3, 4]
+
+    assert ax_con_int_list == [[0], [0]]
+    assert eq_con_int_list == [[0], [0], [1], [1]]
+
+    assert ax_con_list == [[1], [8]]
+    assert eq_con_list == [[14], [4], [18], [11]]
+
+
+def test_triple_bidentate(resource_path_root):
+    xyz_file = (resource_path_root / "inputs" / "ligand_assign_consistent"
+                / "fe_acac_bipy_bipy.xyz")
+    mol = mol3D()
+    mol.readfromxyz(xyz_file)
+
+    liglist, ligdents, ligcons = ligand_breakdown(mol, BondedOct=True)
+    (ax_ligand_list, eq_ligand_list, ax_natoms_list, eq_natoms_list,
+     ax_con_int_list, eq_con_int_list, ax_con_list, eq_con_list,
+     built_ligand_list) = ligand_assign_consistent(mol, liglist, ligdents,
+                                                   ligcons)
+
+    print(ax_ligand_list, eq_ligand_list)
+    ax_formulas = [lig.mol.make_formula(latex=False) for lig in ax_ligand_list]
+    assert ax_formulas == ['O2C5H7', 'N2C10H8']
+    eq_formulas = [lig.mol.make_formula(latex=False) for lig in eq_ligand_list]
+    assert eq_formulas == ['O2C5H7', 'N2C10H8', 'N2C10H8']
+
+    assert ax_natoms_list == [14, 20]
+    assert eq_natoms_list == [14, 20, 20]
+
+    assert ax_con_int_list == [[5], [0]]
+    assert eq_con_int_list == [[0], [1, 0], [1]]
+
+    assert ax_con_list == [[6], [35]]
+    assert eq_con_list == [[1], [16, 15], [36]]

tests/test_ligand_class.py

@@ -0,0 +1,26 @@
+from molSimplify.Classes.ligand import ligand
+
+
+def test_ligand_class(resource_path_root):
+    mol2_file = str(
+        resource_path_root / "inputs" / "ligand_class" / "fe_acac.mol2"
+    )
+    lig = ligand(
+        master_mol=None,
+        index_list=None,
+        dent=None,
+        read_lig=mol2_file,
+    )
+    assert lig.dent == 2
+    assert lig.master_mol.make_formula(latex=False) == "Fe1O2C5H7"
+
+    lig_graph_det, mol2_str = lig.get_lig_mol2()
+    assert lig_graph_det == '-2.023585127e+17'
+
+    with open(resource_path_root / "inputs" / "ligand_class" / "acac_ref.mol2") as fin:
+        ref_str = fin.read()
+    # Remove last new line (because of our autoformatting)
+    assert mol2_str[:-1] == ref_str
+
+    buried_vol = lig.percent_buried_vol()
+    assert abs(buried_vol - 30.034) < 1e-3

tests/test_ligand_from_mol_file.py

@@ -0,0 +1,35 @@
+import pytest
+from molSimplify.Scripts.generator import startgen
+from helperFuncs import working_directory, compareGeo, compare_report_new
+import shutil
+
+
+@pytest.mark.skip("Loading multidentate ligands from files is currently not supported")
+def test_ligand_from_mol_file(tmpdir, resource_path_root):
+    input_file = resource_path_root / "inputs" / "ligand_from_mol_file.in"
+    shutil.copyfile(input_file, tmpdir / "ligand_from_mol_file.in")
+    mol_file = resource_path_root / "inputs" / "pdp.mol"
+    shutil.copyfile(mol_file, tmpdir / "pdp.mol")
+
+    ref_xyz = resource_path_root / "refs" / "ligand_from_mol_file.xyz"
+    ref_report = resource_path_root / "refs" / "ligand_from_mol_file.report"
+
+    threshMLBL = 0.1
+    threshLG = 0.1
+    threshOG = 0.1
+
+    with working_directory(tmpdir):
+        startgen(['main.py', '-i', 'ligand_from_mol_file.in'], flag=False, gui=False)
+
+        jobdir = tmpdir / 'Runs' / 'ligand_from_mol_file'
+        output_xyz = str(jobdir / 'ligand_from_mol_file.xyz')
+        output_report = str(jobdir / 'ligand_from_mol_file.report')
+
+        passNumAtoms, passMLBL, passLG, passOG = compareGeo(
+            output_xyz, ref_xyz, threshMLBL, threshLG, threshOG)
+        assert passNumAtoms
+        assert passMLBL
+        assert passLG
+        assert passOG
+        pass_report = compare_report_new(output_report, ref_report)
+        assert pass_report

tests/test_ligands.py

@@ -0,0 +1,86 @@
+import pytest
+from molSimplify.Classes.mol3D import mol3D
+from molSimplify.Scripts.io import readdict, lig_load
+from importlib_resources import files as resource_files
+from os import listdir
+from os.path import isfile, join
+
+
+path_folder = resource_files("molSimplify").joinpath("Ligands")
+path_dict = resource_files("molSimplify").joinpath("Ligands/ligands.dict")
+lig_dict = readdict(path_dict)
+
+
+@pytest.mark.parametrize("lig_name", lig_dict.keys())
+def test_ligands_dict(lig_name):
+    # Assert that the dict entry has all 6 fields
+    assert len(lig_dict[lig_name]) == 6
+    lig, emsg = lig_load(lig_name)
+    # Assert that the ligand could be loaded
+    assert type(lig) is mol3D
+    assert emsg == ''
+    # Assert that the charge of the loaded ligand equals the
+    # charge noted in ligands.dict
+    charge = int(lig_dict[lig_name][-1][0])
+    assert lig.charge == charge
+    connecting_atoms = lig_dict[lig_name][-4]
+    group = lig_dict[lig_name][-3]
+    if "bidentate" in group:
+        assert len(connecting_atoms) == 2
+    elif "tridentate" in group:
+        assert len(connecting_atoms) == 3
+    elif "tetradentate" in group:
+        assert len(connecting_atoms) == 4
+
+    # Test that there is no style mistake (additional or missing spaces)
+    # in the charge line of .mol files
+    if lig_dict[lig_name][0].endswith('.mol'):
+        with open(f'{path_folder}/{lig_dict[lig_name][0]}') as fin:
+            lines = fin.readlines()
+        for line in lines:
+            if 'CHG' in line:
+                # Should be in the following format:
+                # "M  CHG  n aaa vvv\n"
+                # Where 'n' the number first number after 'CHG' states how
+                # many atom/charge pairs (8 characters each) follow.
+                n_charges = int(line[6:9])
+                # 9 characters including 'n' plus 1 for the newline '/n'
+                assert len(line) == 10 + n_charges * 8
+                sp = line.split()
+                # Recheck that the sum of all charges is the same as the
+                # charge listed in ligands.dict
+                assert sum([int(s) for s in sp[4::2]]) == charge
+
+
+def test_no_repeats():
+    # This test ensures no key is used more than once in ligands.dict.
+    listed_keys = []
+    with open(path_dict) as f:
+        array_content = f.readlines()
+    array_content = [
+        line for line in array_content if not line.startswith("#")
+    ]  # Ignoring comments.
+    listed_keys = [
+        line.split(":")[0] for line in array_content
+    ]  # Grabbing the ligand names.
+    repeated_keys = [
+        item for idx, item in enumerate(listed_keys) if item in listed_keys[:idx]
+    ]  # The repeated ligand names.
+    assert len(repeated_keys) == 0
+
+
+# Identify the files in the Ligands folder.
+my_files = [f for f in listdir(path_folder) if isfile(join(path_folder, f))]
+# Keep only the files that end in .mol or .xyz
+my_files = [f for f in my_files if f.endswith(".xyz") or f.endswith(".mol")]
+# Getting the geometries listed in ligands.dict
+geometries = [
+    entry[1][0] for entry in list(lig_dict.items())
+]  # Requires some ugly indexing to get this done.
+
+
+@pytest.mark.parametrize("file_name", my_files)
+def test_unused_geometries(file_name):
+    # This test checks whether any geometry files in the Ligands folder are not used in ligands.dict.
+    # This indicates that the geometry file should be removed, as it is clutter.
+    assert file_name in geometries