molSimplify 1.7.4__py3-none-any.whl

tests/test_mol3D.py

@@ -0,0 +1,337 @@
+import pytest
+import numpy as np
+from molSimplify.Classes.mol3D import mol3D
+from molSimplify.Classes.atom3D import atom3D
+
+
+def test_adding_and_deleting_atoms():
+    mol = mol3D()
+    mol.addAtom(atom3D(Sym='Fe'))
+
+    assert mol.natoms == 1
+    assert mol.findMetal() == [0]
+
+    mol.addAtom(atom3D(Sym='Cu'))
+
+    assert mol.natoms == 2
+    assert mol.findMetal() == [0, 1]
+
+    mol.deleteatom(0)
+
+    assert mol.natoms == 1
+    assert mol.findMetal() == [0]
+
+
+def test_finding_and_counting_methods():
+    mol = mol3D()
+    mol.addAtom(atom3D(Sym='Fe'))
+    for _ in range(6):
+        mol.addAtom(atom3D(Sym='C'))
+        mol.addAtom(atom3D(Sym='O'))
+
+    # Test find_atom
+    assert mol.find_atom(sym='O') == [2, 4, 6, 8, 10, 12]
+    # Test findAtomsbySymbol
+    assert mol.findAtomsbySymbol(sym='C') == [1, 3, 5, 7, 9, 11]
+    # Test getAtomwithSyms (allows for multiple symbols)
+    ref_indices = [0, 2, 4, 6, 8, 10, 12]
+    assert (mol.getAtomwithSyms(syms=['Fe', 'O'])
+            == [mol.getAtom(i) for i in ref_indices])
+    # optional argument allows to return just the indices:
+    assert (mol.getAtomwithSyms(syms=['Fe', 'O'], return_index=True)
+            == ref_indices)
+    # Test mols_symbols
+    mol.mols_symbols()
+    assert mol.symbols_dict == {'Fe': 1, 'C': 6, 'O': 6}
+    # Test count_nonH_atoms
+    assert mol.count_nonH_atoms() == 13
+    # Test count_atoms (exclude O)
+    assert mol.count_atoms(exclude=['H', 'O']) == 7
+    # Test count_specific_atoms
+    assert mol.count_specific_atoms(atom_types=['C', 'O']) == 12
+    # Test count_electrons
+    assert mol.count_electrons(charge=2) == 24 + 6*6 + 6*8
+    # Test findcloseMetal
+    assert mol.findcloseMetal(mol.getAtom(-1)) == 0
+    # Test findMetal
+    assert mol.findMetal() == [0]
+    # Test make_formula (sorted by atomic number)
+    assert mol.make_formula(latex=False) == 'Fe1O6C6'
+    assert (mol.make_formula(latex=True)
+            == r'\textrm{Fe}_{1}\textrm{O}_{6}\textrm{C}_{6}')
+    # Test typevect
+    np.testing.assert_equal(mol.typevect(), np.array(['Fe'] + ['C', 'O']*6))
+
+
+def test_add_bond():
+    mol = mol3D()
+    mol.addAtom(atom3D(Sym='O'))
+    mol.addAtom(atom3D(Sym='C'))
+    mol.addAtom(atom3D(Sym='H'))
+    mol.addAtom(atom3D(Sym='H'))
+
+    # Initialize empty bo_dict and graph
+    mol.bo_dict = {}
+    mol.graph = np.zeros((4, 4))
+
+    mol.add_bond(0, 1, 2)
+    mol.add_bond(1, 2, 1)
+    mol.add_bond(1, 3, 1)
+
+    assert mol.bo_dict == {(0, 1): 2, (1, 2): 1, (1, 3): 1}
+    np.testing.assert_allclose(mol.graph, [[0, 2, 0, 0],
+                                           [2, 0, 1, 1],
+                                           [0, 1, 0, 0],
+                                           [0, 1, 0, 0]])
+
+    # Assert that bonding an atom to itself fails:
+    with pytest.raises(IndexError):
+        mol.add_bond(0, 0, 1)
+
+    new_bo_dict = mol.get_bo_dict_from_inds([1, 2, 3])
+    assert new_bo_dict == {(0, 1): 1, (0, 2): 1}
+
+    assert mol.get_mol_graph_det(oct=False) == '-154582.1094'
+    assert mol.get_mol_graph_det(oct=False, useBOMat=True) == '-154582.1094'
+
+
+@pytest.mark.skip(reason='Mutating the state of an atom3D can not be detected '
+                         ' by the mol3D class')
+def test_mutating_atoms():
+    mol = mol3D()
+    mol.addAtom(atom3D(Sym='Fe'))
+    assert mol.findMetal() == [0]
+
+    mol.atoms[0].mutate('C')
+    assert mol.findMetal() == []
+
+
+@pytest.mark.parametrize('name, geometry_str', [
+    ('linear', 'linear'),
+    ('trigonal_planar', 'trigonal planar'),
+    ('t_shape', 'T shape'),
+    ('trigonal_pyramidal', 'trigonal pyramidal'),
+    ('tetrahedral', 'tetrahedral'),
+    ('square_planar', 'square planar'),
+    ('seesaw', 'seesaw'),
+    ('trigonal_bipyramidal', 'trigonal bipyramidal'),
+    ('square_pyramidal', 'square pyramidal'),
+    # ('pentagonal_planar', 'pentagonal planar'),
+    ('octahedral', 'octahedral'),
+    # ('pentagonal_pyramidal', 'pentagonal pyramidal'),
+    ('trigonal_prismatic', 'trigonal prismatic'),
+    # ('pentagonal_bipyramidal', 'pentagonal bipyramidal')
+    # ('square_antiprismatic', 'square antiprismatic'),
+    # ('tricapped_trigonal_prismatic', 'tricapped trigonal prismatic'),
+])
+def test_get_geometry_type(resource_path_root, name, geometry_str):
+    xyz_file = resource_path_root / "inputs" / "geometry_type" / f"{name}.xyz"
+    mol = mol3D()
+    mol.readfromxyz(xyz_file)
+
+    geo_report = mol.get_geometry_type(debug=True)
+
+    assert geo_report['geometry'] == geometry_str
+
+
+def test_get_geometry_type_catoms_arr(resource_path_root):
+    xyz_file = resource_path_root / "inputs" / "geometry_type" / "octahedral.xyz"
+    mol = mol3D()
+    mol.readfromxyz(xyz_file)
+
+    with pytest.raises(ValueError):
+        mol.get_geometry_type(catoms_arr=[1], debug=True)
+
+    geo_report = mol.get_geometry_type(catoms_arr=[1, 4, 7, 10, 13, 16], debug=True)
+
+    assert geo_report['geometry'] == 'octahedral'
+
+
+@pytest.mark.parametrize(
+    'name, geometry_str, hapticity',
+    [
+        ('BOWROX_comp_0.mol2', 'tetrahedral', [5, 1, 1, 1]),
+        ('BOXTEQ_comp_0.mol2', 'tetrahedral', [6, 1, 1, 1]),
+        ('BOXTIU_comp_0.mol2', 'tetrahedral', [6, 1, 1, 1]),
+        ('BOZHOQ_comp_2.mol2', 'linear', [5, 5]),
+        ('BOZHUW_comp_2.mol2', 'linear', [5, 5]),
+        ('BUFLUM_comp_0.mol2', 'T shape', [2, 1, 1]),
+        ('BUHMID_comp_0.mol2', 'trigonal planar', [3, 1, 1]),
+        ('COYXUM_comp_0.mol2', 'tetrahedral', [5, 1, 1, 1]),
+        ('COYYEX_comp_0.mol2', 'trigonal planar', [5, 1, 1]),
+        ('COYYIB_comp_0.mol2', 'tetrahedral', [5, 1, 1, 1]),
+    ]
+)
+def test_get_geometry_type_hapticity(resource_path_root, name, geometry_str, hapticity):
+    input_file = resource_path_root / "inputs" / "hapticity_compounds" / name
+    mol = mol3D()
+    mol.readfrommol2(input_file)
+
+    geo_report = mol.get_geometry_type(debug=True)
+
+    print(geo_report)
+    assert geo_report["geometry"] == geometry_str
+    assert geo_report["hapticity"] == hapticity
+
+
+@pytest.mark.parametrize(
+    'name, con_atoms',
+    [
+        ('BOWROX_comp_0.mol2', [{3, 4, 5, 6, 7}]),
+        ('BOXTEQ_comp_0.mol2', [{4, 5, 6, 7, 8, 9}]),
+        ('BOXTIU_comp_0.mol2', [{2, 3, 5, 6, 8, 9}]),
+        ('BOZHOQ_comp_2.mol2', [{1, 2, 3, 6, 8}, {4, 5, 7, 9, 10}]),
+        ('BOZHUW_comp_2.mol2', [{1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}]),
+    ]
+)
+def test_is_sandwich_compound(resource_path_root, name, con_atoms):
+    input_file = resource_path_root / "inputs" / "hapticity_compounds" / name
+    mol = mol3D()
+    mol.readfrommol2(input_file)
+
+    num_sandwich_lig, info_sandwich_lig, aromatic, allconnect, sandwich_lig_atoms = mol.is_sandwich_compound()
+
+    assert num_sandwich_lig == len(con_atoms)
+    assert aromatic
+    assert allconnect
+    for i, (info, lig) in enumerate(zip(info_sandwich_lig, sandwich_lig_atoms)):
+        assert info["aromatic"]
+        assert info["natoms_connected"] == len(con_atoms[i])
+        assert info["natoms_ring"] == len(con_atoms[i])
+        assert lig["atom_idxs"] == con_atoms[i]
+
+
+@pytest.mark.parametrize(
+    'name, con_atoms',
+    [
+        ("BUFLUM_comp_0.mol2", [{2, 4}]),
+        ("BUHMID_comp_0.mol2", [{3, 4, 5}]),
+    ]
+)
+def test_is_edge_compound(resource_path_root, name, con_atoms):
+    input_file = resource_path_root / "inputs" / "hapticity_compounds" / name
+    mol = mol3D()
+    mol.readfrommol2(input_file)
+
+    num_edge_lig, info_edge_lig, edge_lig_atoms = mol.is_edge_compound()
+
+    assert num_edge_lig == len(con_atoms)
+    for i, (info, lig) in enumerate(zip(info_edge_lig, edge_lig_atoms)):
+        assert info["natoms_connected"] == len(con_atoms[i])
+        assert lig["atom_idxs"] == con_atoms[i]
+
+
+def test_readfromxyzfile(resource_path_root):
+    xyz_file = resource_path_root / "inputs" / "cr3_f6_optimization.xyz"
+    mol = mol3D()
+    mol.readfromxyz(xyz_file)
+
+    atoms_ref = [
+        ("Cr", [-0.060052, -0.000019, -0.000023]),
+        ("F", [1.802823, -0.010399, -0.004515]),
+        ("F", [-0.070170, 1.865178, 0.0035660]),
+        ("F", [-1.922959, 0.010197, 0.0049120]),
+        ("F", [-0.049552, -1.865205, -0.0038600]),
+        ("F", [-0.064742, 0.003876, 1.8531400]),
+        ("F", [-0.055253, -0.003594, -1.8531790]),
+    ]
+
+    for atom, ref in zip(mol.atoms, atoms_ref):
+        assert (atom.symbol(), atom.coords()) == ref
+
+    # Test read_final_optim_step
+    mol = mol3D()
+    mol.readfromxyz(xyz_file, read_final_optim_step=True)
+
+    atoms_ref = [
+        ("Cr", [-0.0599865612, 0.0000165451, 0.0000028031]),
+        ("F", [1.8820549261, 0.0000076116, 0.0000163815]),
+        ("F", [-0.0600064919, 1.9420510001, -0.0000022958]),
+        ("F", [-2.0019508544, -0.0000130345, -0.0000067108]),
+        ("F", [-0.0599967119, -1.9420284092, 0.0000133671]),
+        ("F", [-0.0600235008, 0.0000085354, 1.9418467918]),
+        ("F", [-0.0599958059, -0.0000082485, -1.9418293370]),
+    ]
+
+    for atom, ref in zip(mol.atoms, atoms_ref):
+        assert (atom.symbol(), atom.coords()) == ref
+
+
+def test_mol3D_from_smiles_macrocycles():
+    """Uses an examples from Aditya's macrocycles that were previously
+    converted wrong.
+    """
+    smiles = "C9SC(=CCSC(CSC(=NCSC9)))"
+    mol = mol3D.from_smiles(smiles)
+    assert mol.natoms == 29
+
+    ref_graph = np.zeros([mol.natoms, mol.natoms])
+    ref_bo_graph = np.zeros([mol.natoms, mol.natoms])
+    bonds = [
+        (21, 7, 1.0),
+        (29, 14, 1.0),
+        (13, 14, 1.0),
+        (13, 12, 1.0),
+        (9, 10, 1.0),
+        (9, 8, 1.0),
+        (27, 12, 1.0),
+        (6, 7, 1.0),
+        (6, 5, 1.0),
+        (14, 28, 1.0),
+        (14, 1, 1.0),
+        (7, 8, 1.0),
+        (7, 22, 1.0),
+        (2, 1, 1.0),
+        (2, 3, 1.0),
+        (24, 8, 1.0),
+        (12, 11, 1.0),
+        (12, 26, 1.0),
+        (10, 11, 2.0),
+        (10, 25, 1.0),
+        (8, 23, 1.0),
+        (1, 15, 1.0),
+        (1, 16, 1.0),
+        (3, 17, 1.0),
+        (3, 4, 2.0),
+        (5, 19, 1.0),
+        (5, 4, 1.0),
+        (5, 20, 1.0),
+        (4, 18, 1.0),
+    ]
+    for bond in bonds:
+        i, j = bond[0] - 1, bond[1] - 1
+        ref_graph[i, j] = ref_graph[j, i] = 1
+        ref_bo_graph[i, j] = ref_bo_graph[j, i] = bond[2]
+
+    np.testing.assert_allclose(mol.graph, ref_graph)
+    np.testing.assert_allclose(mol.bo_graph, ref_bo_graph)
+
+
+def test_mol3D_from_smiles_benzene():
+    smiles = "c1ccccc1"
+    mol = mol3D.from_smiles(smiles)
+    assert mol.natoms == 12
+
+    ref_graph = np.zeros([mol.natoms, mol.natoms])
+    ref_bo_graph = np.zeros([mol.natoms, mol.natoms])
+    bonds = [
+        (1, 2, 1.5),
+        (2, 3, 1.5),
+        (3, 4, 1.5),
+        (4, 5, 1.5),
+        (5, 6, 1.5),
+        (1, 6, 1.5),
+        (1, 7, 1.0),
+        (2, 8, 1.0),
+        (3, 9, 1.0),
+        (4, 10, 1.0),
+        (5, 11, 1.0),
+        (6, 12, 1.0),
+    ]
+    for bond in bonds:
+        i, j = bond[0] - 1, bond[1] - 1
+        ref_graph[i, j] = ref_graph[j, i] = 1
+        ref_bo_graph[i, j] = ref_bo_graph[j, i] = bond[2]
+
+    np.testing.assert_allclose(mol.graph, ref_graph)
+    np.testing.assert_allclose(mol.bo_graph, ref_bo_graph)

tests/test_molcas_caspt2.py

@@ -0,0 +1,15 @@
+import helperFuncs as hp
+
+
+def test_molcas_caspt2(tmpdir, resource_path_root):
+    testName = "molcas_caspt2"
+    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_molcas_casscf.py

@@ -0,0 +1,15 @@
+import helperFuncs as hp
+
+
+def test_molcas_casscf(tmpdir, resource_path_root):
+    testName = "molcas_casscf"
+    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_old_ANNs.py

@@ -0,0 +1,68 @@
+import helperFuncs as hp
+import numpy as np
+from molSimplify.python_nn.ANN import simple_network_builder
+
+
+def test_old_ANN(tmpdir, resource_path_root):
+    testName = "old_ANN"
+    threshMLBL = 0.1
+    threshLG = 1.0
+    threshOG = 2.0
+    [passNumAtoms, passMLBL, passLG, passOG, pass_report, _] = hp.runtest(
+        tmpdir, resource_path_root, testName, threshMLBL, threshLG, threshOG)
+    assert passNumAtoms
+    assert passMLBL
+    assert passLG
+    assert passOG
+    assert pass_report
+
+
+def test_simple_network_builder():
+    """This test was created by capturing the inputs and outputs generated by
+    the old pybrain implementation during the test_old_ANN() test function."""
+    split_input = np.array(
+        [-0.4917839, -0.56726225, 1.61974697, -0.50082508, -0.30476799,
+         -0.90272848, 0.49027265, 0.65977966, 0.65377293, -0.5926822,
+         -0.86257212, -0.25131881, -0.69807754, 1.76535323, -0.18234301,
+         -0.16467918, -0.82545825, 1.43132271, -0.12278255, 1.52889381,
+         1.11584538, -0.96668963, -1.05525312, -0.95836809, -1.25775219])
+    split_ref_output = np.array([-0.90325581])
+
+    n = simple_network_builder([25, 50, 50], "ms_split")
+    output = n.activate(split_input)
+    np.testing.assert_allclose(output, split_ref_output)
+
+    # Same for slope
+    slope_input = np.array(
+        [-0.48069367, -0.551563, 1.64555217, -0.52515453, -0.31631299,
+         -0.91503729, 0.67783389, 0.66328568, -0.6130196, -0.87338511,
+         -0.25824387, -0.66613123, -0.57789148, 4.88496234, -0.15250621,
+         -0.81416039, -0.69302998, 7.55021286, 1.54277755, 1.11294416,
+         -0.96408929, -1.09251887, -0.97338522, -1.26357339])
+    slope_ref_output = np.array([0.64270068])
+    n = simple_network_builder([24, 50, 50], "ms_slope")
+    output = n.activate(slope_input)
+    np.testing.assert_allclose(output, slope_ref_output)
+
+    ls_input = np.array(
+        [-0.48919416, -0.57361705, 1.62646982, -0.49824537, -0.30638216,
+         -0.92095277, 0.51297477, 0.66726202, 0.66624771, -0.57870037,
+         -0.84940138, -0.24190509, -0.69676993, 1.75745942, -0.1917933,
+         -0.16730346, -0.81139387, 1.43670349, -0.13278737,
+         1.53683663, 1.11609907, -1.03399044, -0.82734353,
+         -0.96566302, -1.26085904])
+    ls_ref_output = np.array([-0.65810288])
+    n = simple_network_builder([25, 50, 50], "ms_ls")
+    output = n.activate(ls_input)
+    np.testing.assert_allclose(output, ls_ref_output)
+
+    hs_input = np.array(
+        [-0.49953556, -0.56090563, 1.650425, -0.51368646, -0.30152256,
+         -0.8952212, 0.5020875, 0.65942027, 0.65335421, -0.56599111,
+         -0.84425765, -0.23805921, -0.69938591, 1.81009507, -0.18946893,
+         -0.15931486, -0.83967322, 1.48102596, -0.12278255, 1.53846941,
+         1.11789832, -1.08058748, -0.87232256, -0.94605866, -1.24373718])
+    hs_ref_output = np.array([-0.54344953])
+    n = simple_network_builder([25, 50, 50], "ms_hs")
+    output = n.activate(hs_input)
+    np.testing.assert_allclose(output, hs_ref_output)

tests/test_orca_ccsdt.py

@@ -0,0 +1,15 @@
+import helperFuncs as hp
+
+
+def test_orca_ccsdt(tmpdir, resource_path_root):
+    testName = "orca_ccsdt"
+    threshMLBL = 0.1
+    threshLG = 1.0
+    threshOG = 8.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_orca_dft.py

@@ -0,0 +1,15 @@
+import helperFuncs as hp
+
+
+def test_orca_dft(tmpdir, resource_path_root):
+    testName = "orca_dft"
+    threshMLBL = 0.1
+    threshLG = 1.0
+    threshOG = 8.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_qcgen.py

@@ -0,0 +1,50 @@
+import pytest
+import shutil
+from argparse import Namespace
+from molSimplify.Scripts.qcgen import (tcgen, gamgen, qgen,
+                                       mlpgen, ogen, molcgen)
+
+
+@pytest.mark.parametrize('gen_function, default_name',
+                         [(tcgen, 'terachem_input'), (gamgen, 'gam.inp'),
+                          (qgen, 'qch.inp'), (mlpgen, 'FeH2O6.mop'),
+                          (ogen, 'orca.in'), (molcgen, 'molcas.input')])
+def test_qcgen_defaults(resource_path_root, gen_function, default_name, tmpdir):
+    """Calls the gen_function with as little parameters as possible to
+    test the default input file generated."""
+    args = Namespace(jobdir=str(tmpdir), reportonly=None, spin=None,
+                     charge=None, runtyp=None, gpus=None, dispersion=None,
+                     basis=None, qoption=None, name=None, tc_fix_dihedral=None,
+                     method=None, oxstate='II', remoption=None, gbasis=None,
+                     correlation=None, unrestricted=None, bsep=None,
+                     ngauss=None, ndfunc=None, npfunc=None, sysoption=None,
+                     ctrloption=None, scfoption=None, statoption=None)
+    xyzfile = resource_path_root / "inputs" / "qcgen" / "FeH2O6.xyz"
+    # Copy xyz file to tmpdir
+    shutil.copy(xyzfile, tmpdir / 'FeH2O6.xyz')
+
+    jobdirs = gen_function(args, [str(tmpdir / 'FeH2O6')], 'B3LYP')
+
+    sub_dir = tmpdir
+    ref_dir = resource_path_root / "refs" / "qcgen" / f"{gen_function.__name__}"
+    # These two generate a different subfolder structure...
+    if gen_function is gamgen or gen_function is qgen:
+        sub_dir = tmpdir / 'FeH2O6/B3LYP'
+        ref_dir = f'{ref_dir}/FeH2O6/B3LYP'
+    assert jobdirs[0] == sub_dir
+
+    ref_file = resource_path_root / ref_dir / default_name
+    with open(ref_file, 'r') as f:
+        ref_lines = f.readlines()
+
+    with open(sub_dir / default_name, 'r') as f:
+        lines = f.readlines()
+
+    # The gamgen input contains a time stamp that has to be removed
+    # prior to comparison:
+    if gen_function is gamgen:
+        ref_lines = [line for line in ref_lines if not line.endswith(
+            'XYZ structure generated by mol3D Class, molSimplify\n')]
+        lines = [line for line in lines if not line.endswith(
+            'XYZ structure generated by mol3D Class, molSimplify\n')]
+    assert lines == ref_lines

tests/test_racs.py

@@ -0,0 +1,124 @@
+import pytest
+import pickle
+from molSimplify.Classes.mol3D import mol3D
+from molSimplify.Classes.ligand import ligand
+from molSimplify.Informatics.RACassemble import create_OHE
+from molSimplify.Informatics.lacRACAssemble import get_descriptor_vector
+from molSimplify.Scripts.io import lig_load
+
+
+@pytest.mark.parametrize('xyz_path, ref_path', [
+    ('fe_carbonyl_6.xyz', 'racs_Fe_carbonyl_6.pickle'),
+    ('mn_furan_water_ammonia_furan_water_ammonia.xyz',
+     'racs_Mn_furan_water_ammonia_furan_water_ammonia.pickle'),
+    ('cr_acac_acac_bipy.xyz',
+     'racs_Cr_acac_acac_bipy.pickle'),
+    ('co_acac_en_water_hydrogensulfide.xyz',
+     'racs_Co_acac_en_water_hydrogensulfide.pickle')])
+def test_Mn_water2_ammonia_furan2_ammonia(resource_path_root, xyz_path, ref_path):
+    xyz_path = resource_path_root / "refs" / "racs" / xyz_path
+    mol = mol3D()
+    mol.readfromxyz(xyz_path)
+    features = mol.get_features()
+
+    ref_path = resource_path_root / "refs" / "racs" / ref_path
+    with open(ref_path, 'rb') as fin:
+        ref_features = pickle.load(fin)
+
+    assert features.keys() == ref_features.keys()
+    for key, val in features.items():
+        assert abs(val - ref_features[key]) < 1e-4
+
+
+def test_six_pyridine_vs_three_bipy(resource_path_root):
+    """Up to depth 2 the atom centered racs features for pyr_6 and bipy_3
+    should be the same"""
+    fe_pyr_6_path = resource_path_root / "refs" / "racs" / "fe_pyr_6.xyz"
+    fe_bipy_3_path = resource_path_root / "refs" / "racs" / "fe_bipy_3.xyz"
+    fe_pyr_6 = mol3D()
+    fe_pyr_6.readfromxyz(fe_pyr_6_path)
+    fe_bipy_3 = mol3D()
+    fe_bipy_3.readfromxyz(fe_bipy_3_path)
+
+    features_pyr = fe_pyr_6.get_features()
+    features_bipy = fe_bipy_3.get_features()
+
+    properties = ['chi', 'Z', 'T', 'S', 'I']
+    start_scopes = [('mc', 'all'), ('lc', 'ax'), ('lc', 'eq'),
+                    ('D_mc', 'all'), ('D_lc', 'ax'), ('D_lc', 'eq')]
+
+    for start, scope in start_scopes:
+        for depth in range(2):
+            for prop in properties:
+                key = f'{start}-{prop}-{depth}-{scope}'
+                assert features_pyr[key] == features_bipy[key]
+
+
+@pytest.mark.skip('Test fails because molSimplify averages the equatorial '
+                  'plane differently for bidentates')
+def test_pyr_4_furan_2_vs_bipy_2_bifuran(resource_path_root):
+    fe_pyr_4_furan_2_path = resource_path_root / "refs" / "racs" / "fe_pyr_4_furan_2.xyz"
+    fe_bipy_2_bifuran_path = resource_path_root / "refs" / "racs" / "fe_bipy_2_bifuran.xyz"
+    fe_pyr_4_furan_2 = mol3D()
+    fe_pyr_4_furan_2.readfromxyz(fe_pyr_4_furan_2_path)
+    fe_bipy_2_bifuran = mol3D()
+    fe_bipy_2_bifuran.readfromxyz(fe_bipy_2_bifuran_path)
+
+    # Enforce the same graph orientation as in bidentates:
+    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
+    pyr = get_ligand('pyr')
+    furan = get_ligand('furan')
+    eq_ligand_list = [pyr, pyr, pyr, furan]
+    ax_ligand_list = [pyr, furan]
+    ligand_dict = {'ax_ligand_list': ax_ligand_list,
+                   'eq_ligand_list': eq_ligand_list,
+                   'ax_con_int_list': [h.mol.cat for h in ax_ligand_list],
+                   'eq_con_int_list': [h.mol.cat for h in eq_ligand_list]}
+    names, values = get_descriptor_vector(fe_pyr_4_furan_2, ligand_dict)
+    features_mono = dict(zip(names, values))
+    features_bi = fe_bipy_2_bifuran.get_features()
+
+    properties = ['Z', 'chi', 'T', 'I', 'S']
+    start_scopes = [('mc', 'all'), ('lc', 'ax'), ('lc', 'eq'),
+                    ('D_mc', 'all'), ('D_lc', 'ax'), ('D_lc', 'eq')]
+
+    for start, scope in start_scopes:
+        for depth in range(2):
+            for prop in properties:
+                key = f'{start}-{prop}-{depth}-{scope}'
+                print(key, features_mono[key], features_bi[key])
+                assert features_mono[key] == features_bi[key]
+
+
+def test_create_OHE():
+    ohe_names, ohe_values = create_OHE('Cr', '2')
+    assert ohe_names == ['ox2', 'ox3', 'd3', 'd4', 'd5', 'd6', 'd7', 'd8']
+    assert ohe_values == [1, 0, 0, 1, 0, 0, 0, 0]
+
+    _, ohe_values = create_OHE('Cr', '3')
+    assert ohe_values == [0, 1, 1, 0, 0, 0, 0, 0]
+
+    _, ohe_values = create_OHE('Mn', '2')
+    assert ohe_values == [1, 0, 0, 0, 1, 0, 0, 0]
+
+    _, ohe_values = create_OHE('Mn', '3')
+    assert ohe_values == [0, 1, 0, 1, 0, 0, 0, 0]
+
+    _, ohe_values = create_OHE('Fe', '2')
+    assert ohe_values == [1, 0, 0, 0, 0, 1, 0, 0]
+
+    _, ohe_values = create_OHE('Fe', '3')
+    assert ohe_values == [0, 1, 0, 0, 1, 0, 0, 0]
+
+    _, ohe_values = create_OHE('Co', '2')
+    assert ohe_values == [1, 0, 0, 0, 0, 0, 1, 0]
+
+    _, ohe_values = create_OHE('Co', '3')
+    assert ohe_values == [0, 1, 0, 0, 0, 1, 0, 0]
+
+    _, ohe_values = create_OHE('Ni', '2')
+    assert ohe_values == [1, 0, 0, 0, 0, 0, 0, 1]