molSimplify 1.7.4__py3-none-any.whl

tests/test_rmsd.py

@@ -0,0 +1,68 @@
+import pytest
+import numpy as np
+from molSimplify.Classes.mol3D import mol3D
+from molSimplify.Scripts.geometry import rotate_around_axis
+from molSimplify.Scripts.rmsd import rigorous_rmsd, quaternion_rotate
+from scipy.spatial.transform import Rotation
+
+
+@pytest.mark.parametrize(
+    'path1,path2,ref_hungarian,ref_none',
+    [['example_1_noff', 'example_1', 0.3991, 0.7749],
+     ['BUWGOQ', 'BUWGOQ_final', 2.43958, 0.49113],
+     ['BUWGOQ_noH', 'BUWGOQ_noH_final', 1.74814, 0.11826],
+     ['BUWGOQ', 'BUWGOQ_final_reordered', 2.43958, 3.02598]]
+    )
+def test_rigorous_rmsd(resource_path_root, path1, path2, ref_hungarian, ref_none, atol=1e-3):
+    # Reference values calculated using https://pypi.org/project/rmsd/
+    # >>> calculate_rmsd --reorder path1.xyz path2.xyz
+    # >>> calculate_rmsd path1.xyz path2.xyz
+    xyz_1 = resource_path_root / "inputs" / "rmsd" / f"{path1}.xyz"
+    mol1 = mol3D()
+    mol1.readfromxyz(xyz_1)
+
+    xyz_2 = resource_path_root / "inputs" / "rmsd" / f"{path2}.xyz"
+    mol2 = mol3D()
+    mol2.readfromxyz(xyz_2)
+
+    r = rigorous_rmsd(mol1, mol2, reorder='hungarian')
+    assert abs(r - ref_hungarian) < atol
+
+    r = rigorous_rmsd(mol1, mol2, reorder='none')
+    assert abs(r - ref_none) < atol
+
+
+@pytest.mark.skip
+def test_methane_rotation(atol=1e-3):
+    """This test case is intended to show the problem with our current RMSD implementation"""
+    # XYZ data copied from
+    # https://github.com/OpenChemistry/avogadrodata/blob/master/data/methane.xyz
+    d = 1.02672
+    theta = 110 * np.pi / 180
+    xyz_string = (
+        "C      0.00000    0.00000    0.0000\n"
+        "H      0.00000    0.00000    1.08900\n"
+        "H      1.02672    0.00000   -0.36300\n"
+        f"H    {d * np.cos(theta):8.5f}   {d * np.sin(theta):8.5f}   -0.36300\n"
+        f"H    {d * np.cos(theta):8.5f}   {-d * np.sin(theta):8.5f}   -0.36300\n"
+    )
+    mol1 = mol3D()
+    mol1.readfromstring(xyz_string)
+
+    mol2 = mol3D()
+    mol2.readfromstring(xyz_string)
+    # rotate 180 degrees around the z axis
+    mol2 = rotate_around_axis(mol2, [0.0, 0.0, 0.0], [0.0, 0.0, 1.0], 180)
+    assert rigorous_rmsd(mol1, mol2, reorder='none') < atol
+
+    assert rigorous_rmsd(mol1, mol2, reorder='hungarian') < atol
+
+
+def test_quaternion_rotate(atol=1e-3):
+    rot_mat = Rotation.from_rotvec(np.array([1., 2., 3.])).as_matrix()
+    x = np.array([[1.2, 0., 0.],
+                  [0., 0., 0.],
+                  [0.5, 0.9, 0.]])
+    y = x @ rot_mat
+
+    np.testing.assert_allclose(quaternion_rotate(x, y), rot_mat, atol=atol)

tests/test_structgen_functions.py

@@ -0,0 +1,198 @@
+import pytest
+import numpy as np
+from argparse import Namespace
+from molSimplify.Classes import atom3D, run_diag
+from molSimplify.Scripts.io import loaddata, lig_load, getlicores
+from molSimplify.Scripts.structgen import (smartreorderligs,
+                                           getbackbcombsall,
+                                           getnupdateb,
+                                           get_MLdist_database,
+                                           get_MLdist,
+                                           init_template,
+                                           init_ANN
+                                           )
+
+
+def test_smartreorderligs():
+    """Expected behavior: First order by denticity, then by number of atom"""
+    indices = smartreorderligs(['water']*6, [1]*6)
+    assert indices == [0, 1, 2, 3, 4, 5]
+
+    indices = smartreorderligs(['water', 'ammonia', 'water', 'water',
+                                'ammonia', 'water'], [1]*6)
+    assert indices == [0, 2, 3, 5, 1, 4]
+
+    indices = smartreorderligs(['ammonia']*3 + ['water']*3, [1]*6)
+    assert indices == [3, 4, 5, 0, 1, 2]
+
+    # 5 monodentates of different sizes
+    indices = smartreorderligs(['furan', 'ammonia', 'pyridine', 'carbonyl',
+                                'water'], [1]*5)
+    assert indices == [3, 4, 1, 0, 2]
+
+    # Test bidentates
+    indices = smartreorderligs(['acac', 'acac', 'en'], [2, 2, 2])
+    assert indices == [2, 0, 1]
+
+    indices = smartreorderligs(['en', 'en', 'acac'], [2, 2, 2])
+    assert indices == [0, 1, 2]
+
+    indices = smartreorderligs(['water', 'carbonyl', 'acac'], [1, 1, 2])
+    assert indices == [2, 1, 0]
+
+    # Tetradentate
+    indices = smartreorderligs(['water', 'porphirine', 'misc'], [1, 4, 1])
+    assert indices == [1, 0, 2]
+
+
+def test_get_MLdist_database():
+    water, _ = lig_load('water')
+    ammonia, _ = lig_load('ammonia')
+    connecting_atom = 0
+    MLbonds = loaddata('/Data/ML.dat')
+
+    dist, exact_match = get_MLdist_database(
+        atom3D(Sym='Fe'), '2', '5', water, connecting_atom, 'water', MLbonds)
+    assert exact_match
+    assert dist == 2.12
+
+    dist, exact_match = get_MLdist_database(
+        atom3D(Sym='Co'), 'III', '5', ammonia,
+        connecting_atom, 'ammonia', MLbonds)
+    assert exact_match
+    assert dist == 2.17
+
+    # Test covariant radii fall back if not in database:
+    dist, exact_match = get_MLdist_database(
+        atom3D(Sym='Fe'), '2', '5', water, connecting_atom, 'water', {})
+
+    assert exact_match is False
+    assert dist == 1.98
+
+    dist, exact_match = get_MLdist_database(
+        atom3D(Sym='Cr'), 'II', '5', water, connecting_atom, 'water', {})
+
+    assert exact_match is False
+    assert dist == 2.0
+
+
+def test_get_MLdist():
+    water, _ = lig_load('water')
+    connecting_atom = 0
+    MLbonds = loaddata('/Data/ML.dat')
+    this_diag = run_diag()
+
+    # Test user defined BL (take second item from supplied list)
+    dist = get_MLdist(atom3D(Sym='Fe'), '2', '5', water, connecting_atom,
+                      'water', ['0', '0', '1.2', '0', '0', '0'], 2, False, 0.0,
+                      this_diag, MLbonds)
+    assert dist == 1.2
+
+    # Test 'c' in bond list
+    dist = get_MLdist(atom3D(Sym='Fe'), '2', '5', water, connecting_atom,
+                      'water', ['0', '0', 'c', '0', '0', '0'], 2, False, 0.0,
+                      this_diag, MLbonds)
+    assert dist == 1.98
+
+    # Test DB lookup
+    dist = get_MLdist(atom3D(Sym='Fe'), '2', '5', water, connecting_atom,
+                      'water', ['False']*6, 2, False, 0.0, this_diag, MLbonds)
+    assert this_diag.dict_bondl
+    assert dist == 2.12
+
+    # Test covalent fall back
+    dist = get_MLdist(atom3D(Sym='Fe'), '2', '5', water, connecting_atom,
+                      'water', ['False']*6, 2, False, 0.0, this_diag, {})
+    assert this_diag.dict_bondl
+    assert dist == 1.98
+
+    # No DB match: use ANN result
+    dist = get_MLdist(atom3D(Sym='Fe'), '2', '5', water, connecting_atom,
+                      'water', ['False']*6, 2, True, 3.14, this_diag, {})
+    assert dist == 3.14
+
+
+@pytest.mark.parametrize(["geometry", "coordination"], [
+    ('no', 1),
+    ('tpl', 3),
+    ('sqp', 4),
+    ('thd', 4),
+    ('spy', 5),
+    ('tbp', 5),
+    ('oct', 6),
+    ('tpr', 6),
+    ('pbp', 7),
+    ('sqap', 8),
+    ('tdhd', 8),
+])
+def test_init_template(geometry, coordination):
+    args = Namespace(geometry=geometry, coord=coordination, ccatoms=None, ligloc=True,
+                     pangles=False, distort='0', core='Fe', calccharge=True,
+                     oxstate='II')
+    (m3D, core3D, geom, backbatoms, coord,
+     corerefatoms) = init_template(args, cpoints_required=6)
+
+    assert [a.sym for a in m3D.getAtoms()] == ['Fe'] + coordination * ['X']
+    # Ugly workaround because atom3D can not be compared directly (the __eq__ method
+    # is commented out because of protein3D incompatiblities)
+    assert [a.__dict__ for a in core3D.getAtoms()] == [atom3D('Fe').__dict__]
+    assert backbatoms == getbackbcombsall(list(range(1, 1 + coordination)))
+    assert geom == geometry
+    assert coord == coordination
+    assert [a.__dict__ for a in corerefatoms.getAtoms()] == [atom3D('Fe').__dict__ for _ in range(coordination)]
+
+
+def test_init_ANN():
+    licores = getlicores()
+
+    # Test skipping:
+    args = Namespace(skipANN=True)
+    (ANN_flag, ANN_bondl, _,
+     ANN_attributes, catalysis_flag) = init_ANN(
+         args, ligands=['water']*6, occs=[1]*6, dents=[1]*6,
+         batslist=[[1], [2], [3], [4], [5], [6]], tcats=[[0]] * 6, licores=licores)
+
+    assert ANN_flag is False
+    assert ANN_bondl == [False] * 6
+    assert ANN_attributes == dict()
+    assert catalysis_flag is False
+
+    # Test oldANN
+    args = Namespace(skipANN=False, oldANN=True, core='Fe', decoration=False,
+                     geometry='oct', oxstate='2', spin='5', debug=False,
+                     exchange=0.2)
+    (ANN_flag, ANN_bondl, _,
+     ANN_attributes, catalysis_flag) = init_ANN(
+         args, ligands=['water']*6, occs=[1]*6, dents=[1]*6,
+         batslist=[[1], [2], [3], [4], [5], [6]], tcats=[[0]] * 6, licores=licores)
+
+    assert ANN_flag
+    assert ANN_bondl == ANN_attributes['ANN_bondl']
+    np.testing.assert_allclose(ANN_bondl, [2.0757] * 6, atol=1e-4)
+    assert catalysis_flag is False
+
+    # Test default ANN
+    args = Namespace(skipANN=False, oldANN=False, core='Fe', decoration=False,
+                     geometry='oct', oxstate='2', spin='5', debug=False,
+                     exchange=0.2)
+    (ANN_flag, ANN_bondl, _,
+     ANN_attributes, catalysis_flag) = init_ANN(
+         args, ligands=['water']*6, occs=[1]*6, dents=[1]*6,
+         batslist=[[1], [2], [3], [4], [5], [6]], tcats=[[0]] * 6, licores=licores)
+
+    assert ANN_flag
+    assert ANN_bondl == ANN_attributes['ANN_bondl']
+    np.testing.assert_allclose(ANN_bondl, [2.1664] * 4 + [2.1349, 2.1218], atol=1e-4)
+    assert catalysis_flag is False
+
+
+def test_getnupdateb():
+    backbone_atoms = [[5, 4, 6], [4, 5], [4, 6], [4], [5], [6]]
+    batoms, backbone_atoms_modified = getnupdateb(backbone_atoms, 3)
+    assert batoms == [5, 4, 6]
+    assert backbone_atoms_modified == []
+
+    backbone_atoms = [[5, 4, 6], [4, 5], [4, 6], [4], [5], [6]]
+    batoms, backbone_atoms_modified = getnupdateb(backbone_atoms, 2)
+    assert batoms == [4, 5]
+    assert backbone_atoms_modified == [[6]]

tests/test_tetrahedral.py

@@ -0,0 +1,29 @@
+import helperFuncs as hp
+
+
+def test_example_1(tmpdir, resource_path_root):
+    testName = "tetrahedral_1"
+    threshMLBL = 0.1  # Change this value for your need
+    threshLG = 0.1  # Change this value for your need
+    threshOG = 2.0  # Change this value for you need
+    [passNumAtoms, passMLBL, passLG, passOG, pass_report, pass_qcin] = hp.runtestNoFF(
+        tmpdir, resource_path_root, testName, threshMLBL, threshLG, threshOG)
+    assert passNumAtoms
+    assert passMLBL
+    assert passLG
+    assert passOG
+    assert pass_report
+
+
+def test_example_2(tmpdir, resource_path_root):
+    testName = "tetrahedral_2"
+    threshMLBL = 0.1  # Change this value for your need
+    threshLG = 0.1  # Change this value for your need
+    threshOG = 2.0  # Change this value for you need
+    [passNumAtoms, passMLBL, passLG, passOG, pass_report, pass_qcin] = hp.runtestNoFF(
+        tmpdir, resource_path_root, testName, threshMLBL, threshLG, threshOG)
+    assert passNumAtoms
+    assert passMLBL
+    assert passLG
+    assert passOG
+    assert pass_report

tests/test_tutorial_10_part_one.py

@@ -0,0 +1,16 @@
+import helperFuncs as hp
+
+
+def test_tutorial_10_part_one(tmpdir, resource_path_root):
+    testName = "tutorial_10_part_one"
+    threshMLBL = 0.1
+    threshLG = 2.0
+    threshOG = 2.0
+    [passNumAtoms, passMLBL, passLG, passOG, pass_report, pass_qcin] = hp.runtest(
+        tmpdir, resource_path_root, testName, threshMLBL, threshLG, threshOG)
+    assert passNumAtoms
+    # Not checking for passMLBL because there are atoms very close to the cutoff
+    # assert passMLBL
+    assert passLG
+    assert passOG
+    assert pass_report

tests/test_tutorial_10_part_two.py

@@ -0,0 +1,15 @@
+import helperFuncs as hp
+
+
+def test_tutorial_10_part_two(tmpdir, resource_path_root):
+    testName = "tutorial_10_part_two"
+    threshMLBL = 0.1
+    threshLG = 7.0
+    threshOG = 7.0
+    [passNumAtoms, passMLBL, passLG, passOG, pass_report, pass_qcin] = hp.runtest(
+        tmpdir, resource_path_root, testName, threshMLBL, threshLG, threshOG)
+    assert passNumAtoms
+    assert passMLBL
+    assert passLG
+    assert passOG
+    assert pass_report

tests/test_tutorial_2.py

@@ -0,0 +1,11 @@
+import helperFuncs as hp
+
+
+def test_tutorial_2(tmpdir, resource_path_root):
+    testName = "tutorial_2"
+    threshOG = 2.0
+    [passNumAtoms, passOG] = hp.runtest_slab(
+        tmpdir, resource_path_root, testName, threshOG,
+        extra_files=['pd_test_tutorial_2.cif'])
+    assert passNumAtoms
+    assert passOG

tests/test_tutorial_3.py

@@ -0,0 +1,15 @@
+import helperFuncs as hp
+
+
+def test_tutorial_3(tmpdir, resource_path_root):
+    testName = "tutorial_3"
+    threshMLBL = 0.1
+    threshLG = 1.0
+    threshOG = 2.0
+    [passNumAtoms, passMLBL, passLG, passOG, pass_report, pass_qcin] = hp.runtest(
+        tmpdir, resource_path_root, testName, threshMLBL, threshLG, threshOG)
+    assert passNumAtoms
+    assert passMLBL
+    assert passLG
+    assert passOG
+    assert pass_report

tests/test_tutorial_4.py

@@ -0,0 +1,57 @@
+import shutil
+from molSimplify.Classes.globalvars import globalvars
+from molSimplify.Scripts.generator import startgen
+from helperFuncs import parse4test, working_directory
+
+
+def run_db_search(tmpdir, resource_path_root, name):
+    # Set the path for the data base file:
+    globs = globalvars()
+    globs.chemdbdir = str(resource_path_root / "inputs")
+
+    infile = resource_path_root / "inputs" / name
+    newinfile, _ = parse4test(infile, tmpdir)
+    args = ['main.py', '-i', newinfile]
+
+    with working_directory(tmpdir):
+        startgen(args, False, False)
+
+
+def test_tutorial_4_query(tmpdir, resource_path_root):
+    run_db_search(tmpdir, resource_path_root, "tutorial_4_query.in")
+
+    # Compare the generated output file to the reference file
+    with open(f"{tmpdir}/simres.smi", "r") as f:
+        output = f.readlines()
+    with open(resource_path_root / "refs" / "tutorial_4" / "simres.smi") as f:
+        reference = f.readlines()
+
+    assert output == reference
+
+
+def test_tutorial_4_dissim(tmpdir, resource_path_root):
+    # Copy the results from the query into the working directory
+    shutil.copyfile(resource_path_root / "refs" / "tutorial_4" / "simres.smi",
+                    tmpdir / "simres.smi")
+
+    run_db_search(tmpdir, resource_path_root, "tutorial_4_dissim.in")
+
+    # Compare the generated output file to the reference file
+    with open(f"{tmpdir}/dissimres.smi", "r") as f:
+        output = f.readlines()
+    with open(resource_path_root / "refs" / "tutorial_4" / "dissimres.smi") as f:
+        reference = f.readlines()
+
+    assert output == reference
+
+
+def test_tutorial_4_human(tmpdir, resource_path_root):
+    run_db_search(tmpdir, resource_path_root, "tutorial_4_human.in")
+
+    # Compare the generated output file to the reference file
+    with open(f"{tmpdir}/simres.smi", "r") as f:
+        output = f.readlines()
+    with open(resource_path_root / "refs" / "tutorial_4" / "simres_human.smi") as f:
+        reference = f.readlines()
+
+    assert output == reference

tests/test_tutorial_6.py

@@ -0,0 +1,10 @@
+import helperFuncs as hp
+
+
+def test_tutorial_6(tmpdir, resource_path_root):
+    testName = "tutorial_6"
+    threshOG = 2.0
+    [passNumAtoms, passOG] = hp.runtest_molecule_on_slab(
+        tmpdir, resource_path_root, testName, threshOG)
+    assert passNumAtoms
+    assert passOG

tests/test_tutorial_8.py

@@ -0,0 +1,29 @@
+import helperFuncs as hp
+
+
+def test_tutorial_8_part_one(tmpdir, resource_path_root):
+    testName = "tutorial_8_part_one"
+    threshMLBL = 0.1
+    threshLG = 1.0
+    threshOG = 2.0
+    [passNumAtoms, passMLBL, passLG, passOG, pass_report, pass_qcin] = hp.runtest(
+        tmpdir, resource_path_root, testName, threshMLBL, threshLG, threshOG)
+    assert passNumAtoms
+    assert passMLBL
+    assert passLG
+    assert passOG
+    assert pass_report
+
+
+def test_tutorial_8_part_two(tmpdir, resource_path_root):
+    testName = "tutorial_8_part_two"
+    threshMLBL = 0.1
+    threshLG = 1.0
+    threshOG = 2.0
+    [passNumAtoms, passMLBL, passLG, passOG, pass_report, pass_qcin] = hp.runtest(
+        tmpdir, resource_path_root, testName, threshMLBL, threshLG, threshOG)
+    assert passNumAtoms
+    assert passMLBL
+    assert passLG
+    assert passOG
+    assert pass_report

tests/test_tutorial_9_part_one.py

@@ -0,0 +1,15 @@
+import helperFuncs as hp
+
+
+def test_tutorial_09_part_one(tmpdir, resource_path_root):
+    testName = "tutorial_09_part_one"
+    threshMLBL = 0.1
+    threshLG = 2.0
+    threshOG = 2.0
+    [passNumAtoms, passMLBL, passLG, passOG, pass_report, pass_qcin] = hp.runtest(
+        tmpdir, resource_path_root, testName, threshMLBL, threshLG, threshOG)
+    assert passNumAtoms
+    assert passMLBL
+    assert passLG
+    assert passOG
+    assert pass_report

tests/test_tutorial_9_part_two.py

@@ -0,0 +1,15 @@
+import helperFuncs as hp
+
+
+def test_tutorial_09_part_two(tmpdir, resource_path_root):
+    testName = "tutorial_09_part_two"
+    threshMLBL = 0.1
+    threshLG = 2.0
+    threshOG = 2.0
+    [passNumAtoms, passMLBL, passLG, passOG, pass_report, pass_qcin] = hp.runtest(
+        tmpdir, resource_path_root, testName, threshMLBL, threshLG, threshOG)
+    assert passNumAtoms
+    assert passMLBL
+    assert passLG
+    assert passOG
+    assert pass_report

tests/test_tutorial_qm9_part_one.py

@@ -0,0 +1,6 @@
+import helperFuncs as hp
+
+
+def test_tutorial_qm9_part_one(tmpdir, resource_path_root):
+    testName = "tutorial_qm9_part_one"
+    hp.runtest_num_atoms_in_xyz(tmpdir, resource_path_root, testName)

tests/testresources/refs/racs/generate_references.py

@@ -0,0 +1,85 @@
+import pickle
+from molSimplify.Classes.mol3D import mol3D
+from molSimplify.Classes.atom3D import atom3D
+from molSimplify.Classes.ligand import ligand
+from molSimplify.Scripts.io import lig_load
+from molSimplify.Informatics.RACassemble import assemble_connectivity_from_parts
+from molSimplify.Informatics.lacRACAssemble import get_descriptor_vector
+
+
+def get_ligand(lig_str):
+    lig_mol, _ = lig_load(lig_str)
+    lig = ligand(mol3D(), lig_mol.cat, lig_mol.denticity)
+    lig.mol = lig_mol
+    return lig
+
+
+def generate_ligand_dict(eq_ligands, ax_ligands):
+    eq_ligand_list = []
+    for lig_str in eq_ligands:
+        eq_ligand_list.append(get_ligand(lig_str))
+
+    ax_ligand_list = []
+    for lig_str in ax_ligands:
+        ax_ligand_list.append(get_ligand(lig_str))
+
+    ligand_dict = {'eq_ligand_list': eq_ligand_list,
+                   'ax_ligand_list': ax_ligand_list,
+                   'eq_con_int_list': [h.mol.cat for h in eq_ligand_list],
+                   'ax_con_int_list': [h.mol.cat for h in ax_ligand_list]
+                   }
+    return ligand_dict
+
+
+def assemble_mol(metal_str, eq_ligands, ax_ligands):
+    metal = mol3D()
+    metal.addAtom(atom3D(Sym=metal_str))
+
+    ligand_dict = generate_ligand_dict(eq_ligands, ax_ligands)
+
+    mol = assemble_connectivity_from_parts(metal, ligand_dict)
+    print(f'assembled mol: {mol.make_formula(latex=False)}')
+    return mol
+
+
+def features_from_mol(mol, ligand_dict):
+    names, racs = get_descriptor_vector(mol, custom_ligand_dict=ligand_dict)
+    features = dict(zip(names, racs))
+    return features
+
+
+def generate_features(metal_str, eq_ligands, ax_ligands):
+    ligand_dict = generate_ligand_dict(eq_ligands, ax_ligands)
+    mol = assemble_mol(metal_str, eq_ligands, ax_ligands)
+    return features_from_mol(mol, ligand_dict)
+
+
+def main():
+    features = generate_features('Fe', ['carbonyl']*4, ['carbonyl']*2)
+    with open('racs_Fe_carbonyl_6.pickle', 'wb') as f:
+        pickle.dump(features, f)
+
+    features = generate_features('Mn', ['furan', 'water', 'ammonia', 'furan'],
+                                 ['water', 'ammonia'])
+    with open('racs_Mn_furan_water_ammonia_furan_water_ammonia.pickle', 'wb') as f:
+        pickle.dump(features, f)
+
+    features = generate_features('Co', ['acac', 'en'], ['water', 'hydrogensulfide'])
+    with open('racs_Co_acac_en_water_hydrogensulfide.pickle', 'wb') as f:
+        pickle.dump(features, f)
+
+    acac = get_ligand('acac')
+    bipy = get_ligand('bipy')
+    ligand_dict = {
+        'ax_ligand_list': [acac, acac],
+        'eq_ligand_list': [acac, acac, bipy],
+        'ax_con_int_list': [[0], [0]],
+        'eq_con_int_list': [[5], [5], [0, 1]]}
+    mol = assemble_mol('Cr', ['acac', 'bipy'], ['acac'])
+    features = features_from_mol(mol, ligand_dict)
+    with open('racs_Cr_acac_acac_bipy.pickle', 'wb') as f:
+        pickle.dump(features, f)
+
+
+if __name__ == '__main__':
+    main()