molSimplify 1.7.4__py3-none-any.whl

tests/informatics/test_MOF_descriptors.py

@@ -0,0 +1,128 @@
+import pytest
+import json
+import numpy as np
+import pandas as pd
+from molSimplify.Informatics.MOF.MOF_descriptors import get_MOF_descriptors
+from molSimplify.utils.timer import DebugTimer
+
+
+@pytest.fixture
+def ref_names():
+    def RACs_names(depth=3, Gval=True, alpha=True):
+
+        def generate_names(starts, properties, depth, scope="all"):
+            names = []
+            for start in starts:
+                for prop in properties:
+                    for d in range(depth + 1):
+                        if scope is None:
+                            names.append(f"{start}-{prop}-{d}")
+                        else:
+                            names.append(f"{start}-{prop}-{d}-{scope}")
+            return names
+
+        properties = ["chi", "Z", "I", "T", "S"]
+        if Gval:
+            properties.append("Gval")
+
+        names = generate_names(["f", "mc", "D_mc"], properties, depth)
+        # f-lig does not include the "scope"
+        names.extend(generate_names(["f-lig"], properties, depth, scope=None))
+
+        # Same for the starts that include the additional property alpha
+        if alpha:
+            properties.append("alpha")
+        names.extend(
+            generate_names(["lc", "D_lc", "func", "D_func"], properties, depth))
+        return names
+    return RACs_names
+
+
+@pytest.mark.parametrize(
+    "name",
+    [
+        "odac-21383",
+        "odac-21433",
+        "odac-21478",
+        "odac-21735",
+        "odac-21816",
+    ])
+def test_get_MOF_descriptors_ODAC(resource_path_root, tmpdir, name, ref_names):
+    # NOTE All the .cif files were converted to primitive unit cell using the
+    # MOF_descriptors.get_primitive() function
+
+    with DebugTimer("get_MOF_descriptors()"):
+        full_names, full_descriptors = get_MOF_descriptors(
+            str(resource_path_root / "inputs" / "cif_files" / f"{name}.cif"),
+            depth=3,
+            path=str(tmpdir),
+            xyzpath=str(tmpdir / "test.xyz"),
+            Gval=True,
+        )
+
+    with open(resource_path_root / "refs" / "MOF_descriptors"
+              / name / f"{name}.json", "r") as fin:
+        ref = json.load(fin)
+
+    assert full_names == ref_names()
+    np.testing.assert_allclose(full_descriptors, ref["descriptors"], atol=1e-6)
+
+    lc_descriptors = pd.read_csv(tmpdir / "lc_descriptors.csv")
+    lc_ref = pd.read_csv(resource_path_root / "refs" / "MOF_descriptors" / name / "lc_descriptors.csv")
+    assert all(lc_descriptors == lc_ref)
+
+    sbu_descriptors = pd.read_csv(tmpdir / "sbu_descriptors.csv")
+    sbu_ref = pd.read_csv(resource_path_root / "refs" / "MOF_descriptors" / name / "sbu_descriptors.csv")
+    assert all(sbu_descriptors == sbu_ref)
+
+
+@pytest.mark.parametrize(
+    "name",
+    [
+        "FOKYIP_clean",
+        "SETDUS_clean",
+        "UXUPEK_clean",
+        "NEXXIZ_clean",
+        # "ETECIR_clean",  TODO: Figure out why these two example do not work!
+        # "FAVGUH_clean",  Disagreement on all ligand center RACs
+        "YICDAR_clean",
+        "VONBIK_clean",
+    ])
+def test_get_MOF_descriptors_JACS(resource_path_root, tmpdir, name, ref_names):
+    """
+    Tests a handful of the MOFs used in
+    Nandy et al., J. Am. Chem. Soc. 2021, 143, 42, 17535-17547
+    https://doi.org/10.1021/jacs.1c07217
+    """
+    # NOTE All the .cif files were converted to primitive unit cell using the
+    # MOF_descriptors.get_primitive() function
+
+    with DebugTimer("get_MOF_descriptors()"):
+        full_names, full_descriptors = get_MOF_descriptors(
+            str(resource_path_root / "inputs" / "cif_files" / f"{name}.cif"),
+            depth=3,
+            path=str(tmpdir),
+            xyzpath=str(tmpdir / "test.xyz"),
+            Gval=False,
+        )
+
+    with open(resource_path_root / "refs" / "MOF_descriptors"
+              / name / f"{name}.json", "r") as fin:
+        ref = json.load(fin)
+
+    # For now we are using a workaround because polarization descriptors
+    # are now added by default.
+    # Here they should be compared to ref_names(Gval=False, alpha=False)
+    assert full_names == ref_names(Gval=False, alpha=True)
+    np.testing.assert_allclose(
+        # Get only the subset of descriptors without the property alpha
+        [d for d, n in zip(full_descriptors, full_names) if "alpha" not in n],
+        ref["descriptors"], atol=1e-6)
+
+    lc_descriptors = pd.read_csv(tmpdir / "lc_descriptors.csv")
+    lc_ref = pd.read_csv(resource_path_root / "refs" / "MOF_descriptors" / name / "lc_descriptors.csv")
+    assert all(lc_descriptors == lc_ref)
+
+    sbu_descriptors = pd.read_csv(tmpdir / "sbu_descriptors.csv")
+    sbu_ref = pd.read_csv(resource_path_root / "refs" / "MOF_descriptors" / name / "sbu_descriptors.csv")
+    assert all(sbu_descriptors == sbu_ref)

tests/informatics/test_active_learning.py

@@ -0,0 +1,113 @@
+import pytest
+import numpy as np
+from molSimplify.Informatics.active_learning.expected_improvement import (
+    get_2D_pareto_indices,
+    get_2D_PI_and_centroid,
+    get_2D_EI,
+    get_2D_EHVI,
+)
+
+
+def test_get_pareto_indices():
+    points = np.random.default_rng(0).normal(size=(500, 2))
+
+    pareto_indices = get_2D_pareto_indices(points)
+    np.testing.assert_equal(pareto_indices, [239, 119, 308, 95, 49, 230, 79, 206, 151])
+
+    # Also test the 3 other quadrants:
+    # Maximize dimension 0, minimize dimension 1
+    points[:, 0] *= -1
+    pareto_indices = get_2D_pareto_indices(points)
+    np.testing.assert_equal(pareto_indices, [135, 331, 376, 247, 34, 151])
+
+    # Maximize dimension 0, maximize dimension 1
+    points[:, 1] *= -1
+    pareto_indices = get_2D_pareto_indices(points)
+    np.testing.assert_equal(pareto_indices, [135, 258, 23, 489, 466, 123, 109])
+
+    # Minimize dimension 0, maximize dimension 1
+    points[:, 0] *= -1
+    pareto_indices = get_2D_pareto_indices(points)
+    np.testing.assert_equal(pareto_indices, [239, 69, 175, 201, 389, 109])
+
+
+@pytest.mark.parametrize(
+    "method, ref_PI",
+    [
+        ("aug", [0.331885, 0.75219, 0.853196]),
+        ("dom", [0.062788, 0.185605, 0.640678]),
+        ("mix", [0.197337, 0.468897, 0.746937]),
+    ]
+)
+def test_get_2D_PI_and_centroid(method, ref_PI, atol=1e-6):
+    pred_mean = np.array([[5.0, 5.0], [3.0, 6.0], [3.0, 3.0]])
+    pred_std = np.array([[1.2, 1.4], [1.1, 0.8], [2.6, 1.1]])
+    pareto_points = np.array(
+        [[2.0, 7.0], [4.0, 4.0], [6.0, 2.0], [8.0, 1.0]])
+
+    PI_xy, centroid_xy = get_2D_PI_and_centroid(
+        pred_mean, pred_std, pareto_points, method=method)
+    # Now swap axis and assert that the PI is the same and that the centroids
+    # also swapped axis.
+    # NOTE: the pareto_points must also be reversed to satisfy the ordering constraints
+    PI_yx, centroid_yx = get_2D_PI_and_centroid(
+        pred_mean[:, ::-1], pred_std[:, ::-1], pareto_points[::-1, ::-1],
+        method=method)
+
+    np.testing.assert_allclose(PI_xy, PI_yx, atol=atol)
+    np.testing.assert_allclose(centroid_xy, centroid_yx[:, ::-1], atol=atol)
+    np.testing.assert_allclose(PI_xy, ref_PI, atol=atol)
+
+
+@pytest.mark.parametrize(
+    "method, ref_EI",
+    [
+        ("aug", [0.033024, 0.966226, 1.684631]),
+        ("dom", [0.066208, 0.220915, 1.708273]),
+        ("mix", [0.017599, 0.551167, 1.693937]),
+    ]
+)
+def test_get_2D_EI(method, ref_EI, atol=1e-6):
+    pred_mean = np.array([[5.0, 5.0], [3.0, 6.0], [3.0, 3.0]])
+    pred_std = np.array([[1.2, 1.4], [1.1, 0.8], [2.6, 1.1]])
+    pareto_points = np.array(
+        [[2.0, 7.0], [4.0, 4.0], [6.0, 2.0], [8.0, 1.0]])
+
+    EI_xy = get_2D_EI(pred_mean, pred_std, pareto_points, method=method)
+    # Now swap axis and assert that the EI is the same
+    # NOTE: the pareto_points must also be reversed to satisfy the ordering constraints
+    EI_yx = get_2D_EI(pred_mean[:, ::-1], pred_std[:, ::-1], pareto_points[::-1, ::-1],
+                      method=method)
+
+    np.testing.assert_allclose(EI_xy, EI_yx, atol=atol)
+    np.testing.assert_allclose(EI_xy, ref_EI, atol=atol)
+
+
+@pytest.mark.parametrize(
+    "pred_mean, pred_std, pareto_points, r, ref_EHVI",
+    [
+        (np.array([[0.0, 0.0]]),
+         np.array([[0.1, 0.1]]),
+         np.array([[0.0, 2.0], [1.0, 1.0], [2.0, 0.0]]),
+         np.array([3.0, 3.0]),
+         [3.07978846]),
+        (np.array([[10.0, 10.0]]),
+         np.array([[4.0, 4.0]]),
+         np.array([[1.0, 2.0], [2.0, 1.0]]),
+         np.array([11.0, 11.0]),
+         [0.0726813]),
+        (np.array([[5.0, 5.0], [3.0, 6.0], [3.0, 3.0]]),
+         np.array([[1.2, 1.4], [1.1, 0.8], [2.6, 1.1]]),
+         np.array([[2.0, 7.0], [4.0, 4.0], [6.0, 2.0], [8.0, 1.0]]),
+         np.array([10.0, 10.0]),
+         [0.4975774, 1.4780866, 10.2390386]),
+    ]
+)
+def test_get_2D_EHVI(pred_mean, pred_std, pareto_points, r, ref_EHVI, atol=1e-6):
+    EHVI_xy = get_2D_EHVI(pred_mean, pred_std, pareto_points, r)
+    # Now swap axis and assert that the EHVI is the same
+    # NOTE: the pareto_points must also be reversed to satisfy the ordering constraints
+    EHVI_yx = get_2D_EHVI(pred_mean[:, ::-1], pred_std[:, ::-1], pareto_points[::-1, ::-1], r[::-1])
+
+    np.testing.assert_allclose(EHVI_xy, EHVI_yx, atol=atol)
+    np.testing.assert_allclose(EHVI_xy, ref_EHVI, atol=atol)

tests/informatics/test_coulomb_analyze.py

@@ -0,0 +1,24 @@
+import numpy as np
+from molSimplify.Classes.mol3D import mol3D
+from molSimplify.Informatics.coulomb_analyze import create_coulomb_matrix
+
+
+def test_create_coulomb_matrix(resource_path_root):
+    xyz_file = resource_path_root / "inputs" / "cr3_f6_optimization.xyz"
+    mol = mol3D()
+    mol.readfromxyz(xyz_file)
+    cm = create_coulomb_matrix(mol)
+    print(cm)
+    nuclear_charges = np.array([24., 9., 9., 9., 9., 9., 9.])
+    xyzs = mol.coordsvect()
+    r = np.sqrt(np.sum((xyzs[:, np.newaxis, :] - xyzs[np.newaxis, :, :])**2, axis=-1))
+    ref = np.outer(nuclear_charges, nuclear_charges)
+    ref[r > 0.] /= r[r > 0.]
+    ref[np.diag_indices_from(ref)] = 0.5 * nuclear_charges ** 2.4
+    # Finally sort by L2 norm
+    norms = np.linalg.norm(ref, axis=0)
+    inds = np.argsort(norms)[::-1]
+    ref = ref[inds, :]
+    ref = ref[:, inds]
+    print(ref)
+    np.testing.assert_allclose(cm, ref, atol=1e-8)

tests/informatics/test_graph_racs.py

@@ -0,0 +1,193 @@
+import pytest
+import operator
+import json
+import numpy as np
+from molSimplify.Classes.mol2D import Mol2D
+from molSimplify.Informatics.graph_racs import (
+    atom_centered_AC,
+    multi_centered_AC,
+    octahedral_racs,
+    ligand_racs,
+)
+
+
+@pytest.fixture
+def furan():
+    mol = Mol2D()
+    mol.add_nodes_from(
+        [
+            (0, {"symbol": "O"}),
+            (1, {"symbol": "C"}),
+            (2, {"symbol": "C"}),
+            (3, {"symbol": "C"}),
+            (4, {"symbol": "C"}),
+            (5, {"symbol": "H"}),
+            (6, {"symbol": "H"}),
+            (7, {"symbol": "H"}),
+            (8, {"symbol": "H"}),
+        ]
+    )
+    mol.add_edges_from(
+        [(0, 1), (1, 2), (2, 3), (3, 4), (0, 4), (1, 5), (2, 6), (4, 7), (3, 8)]
+    )
+    return mol
+
+
+def test_atom_centered_AC(furan):
+    descriptors = atom_centered_AC(furan, 0, depth=3)
+    # properties: Z, chi, T,  I, S
+    ref = [
+        [64.0, 11.8336, 4.0, 1.0, 0.5329],
+        [96.0, 17.544, 12.0, 2.0, 1.1242],
+        [112.0, 32.68, 16.0, 4.0, 1.6644],
+        [16.0, 15.136, 4.0, 2.0, 0.5402],
+    ]
+    np.testing.assert_allclose(descriptors, ref)
+
+
+def test_atom_centered_AC_diff(furan):
+    descriptors = atom_centered_AC(furan, 0, depth=3, operation=operator.sub)
+    # properties: Z, chi, T,  I, S
+    ref = [
+        [0.0, 0.0, 0.0, 0.0, 0.0],
+        [4.0, 1.78, -2.0, 0.0, -0.08],
+        [18.0, 4.26, 0.0, 0.0, 0.64],
+        [14.0, 2.48, 2.0, 0.0, 0.72],
+    ]
+    np.testing.assert_allclose(descriptors, ref)
+
+
+def test_multi_centered_AC(furan):
+    descriptors = multi_centered_AC(furan, depth=3)
+    # properties: Z, chi, T,  I, S
+    ref = [
+        [212.0, 57.2036, 44.0, 9.0, 3.4521],
+        [456.0, 118.983, 102.0, 18.0, 8.0850],
+        [512.0, 171.695, 122.0, 26.0, 10.3050],
+        [110.0, 126.632, 50.0, 22.0, 5.3206],
+    ]
+    np.testing.assert_allclose(descriptors, ref)
+
+
+@pytest.mark.parametrize(
+    "mol2_path, ref_path, eq_atoms",
+    [
+        ("fe_carbonyl_6.mol2", "racs_Fe_carbonyl_6.json", None),
+        (
+            "mn_furan_water_ammonia_furan_water_ammonia.mol2",
+            "racs_Mn_furan_water_ammonia_furan_water_ammonia.json",
+            [10, 1, 17, 13],  # From ligand_assign_consistent
+        ),
+        (
+            "co_acac_en_water_hydrogensulfide.mol2",
+            "racs_Co_acac_en_water_hydrogensulfide.json",
+            [15, 16, 1, 6],  # From ligand_assign_consistent
+        ),
+    ],
+)
+def test_octahedral_racs(
+    resource_path_root, mol2_path, ref_path, eq_atoms, atol=1e-4
+):
+
+    mol = Mol2D.from_mol2_file(resource_path_root / "inputs" / "informatics" / mol2_path)
+
+    with open(resource_path_root / "refs" / "informatics" / ref_path, "r") as fin:
+        ref_dict = json.load(fin)
+
+    depth = 3
+    properties = ["Z", "chi", "T", "I", "S"]
+    descriptors = octahedral_racs(
+        mol,
+        depth=depth,
+        equatorial_connecting_atoms=eq_atoms,
+    )
+
+    # Dictionary encoding the order of the descriptors in the numpy array
+    start_scopes = {
+        0: ("f", "all"),
+        1: ("mc", "all"),
+        2: ("lc", "ax"),
+        3: ("lc", "eq"),
+        4: ("f", "ax"),
+        5: ("f", "eq"),
+        6: ("D_mc", "all"),
+        7: ("D_lc", "ax"),
+        8: ("D_lc", "eq"),
+    }
+
+    for s, (start, scope) in start_scopes.items():
+        for d in range(depth + 1):
+            for p, prop in enumerate(properties):
+                print(
+                    start,
+                    scope,
+                    d,
+                    prop,
+                    descriptors[s, d, p],
+                    ref_dict[f"{start}-{prop}-{d}-{scope}"],
+                )
+                assert (
+                    abs(descriptors[s, d, p] - ref_dict[f"{start}-{prop}-{d}-{scope}"])
+                    < atol
+                )
+
+
+@pytest.mark.parametrize(
+    "mol2_path, ref_path, n_ligs",
+    [
+        ("fe_carbonyl_6.mol2", "lig_racs_fe_carbonyl_6.json", 6),
+        (
+            "mn_furan_water_ammonia_furan_water_ammonia.mol2",
+            "lig_racs_mn_furan_water_ammonia_furan_water_ammonia.json",
+            6,
+        ),
+        (
+            "co_acac_en.mol2",
+            "lig_racs_co_acac_en.json",
+            4,
+        ),
+    ],
+)
+def test_ligand_racs(
+    resource_path_root, mol2_path, ref_path, n_ligs, atol=1e-4
+):
+
+    mol = Mol2D.from_mol2_file(resource_path_root / "inputs" / "informatics" / mol2_path)
+
+    with open(resource_path_root / "refs" / "informatics" / ref_path, "r") as fin:
+        ref_dict = json.load(fin)
+    print(ref_dict)
+
+    depth = 3
+    descriptors = ligand_racs(
+        mol,
+        depth=depth,
+        full_scope=True
+    )
+
+    assert descriptors.shape == (n_ligs, 4, depth + 1, 5)
+
+    starts = {
+        0: "lc_P",
+        1: "lc_D",
+        2: "f_P",
+        3: "f_D",
+    }
+
+    properties = ["Z", "chi", "T", "I", "S"]
+    for lig in range(n_ligs):
+        for s, start in starts.items():
+            for d in range(depth + 1):
+                for p, prop in enumerate(properties):
+                    print(
+                        f"lig_{lig}",
+                        start,
+                        d,
+                        prop,
+                        descriptors[lig, s, d, p],
+                        ref_dict[f"lig_{lig}-{start}-{prop}-{d}"],
+                    )
+                    assert (
+                        abs(descriptors[lig, s, d, p] - ref_dict[f"lig_{lig}-{start}-{prop}-{d}"])
+                        < atol
+                    )

tests/ml/test_kernels.py

@@ -0,0 +1,20 @@
+import numpy as np
+from molSimplify.ml.kernels import Masking
+from sklearn.gaussian_process.kernels import RBF
+
+
+def test_masking():
+    rng = np.random.default_rng(0)
+    X = rng.normal(1.2, 0.4, size=(10, 4))
+    Y = rng.normal(1.1, 0.5, size=(7, 4))
+
+    mask = [True, False, True, False]
+    kernel = Masking(mask, RBF(length_scale=1.5))
+    kernel_ref = RBF(length_scale=1.5)
+
+    np.testing.assert_allclose(kernel(X), kernel_ref(X[:, mask]))
+    np.testing.assert_allclose(kernel(X, Y), kernel_ref(X[:, mask], Y[:, mask]))
+
+    # Second use case, with a slice mask, equivalent to ::2
+    kernel2 = Masking(slice(None, None, 2), RBF(length_scale=1.5))
+    np.testing.assert_allclose(kernel(X, Y), kernel2(X, Y))

tests/ml/test_layers.py

@@ -0,0 +1,47 @@
+import numpy as np
+import tensorflow as tf
+from molSimplify.ml.layers import PermutationLayer
+
+
+def test_permutation_layer():
+    permutations = [
+        (0, 1),
+        (1, 0),
+    ]
+
+    layer = PermutationLayer(permutations=permutations)
+
+    rng = np.random.default_rng(0)
+    X_tmc = rng.normal(1.2, 0.4, size=(10, 4))
+    X_ligand = rng.normal(1.1, 0.5, size=(10, 2, 4))
+
+    output = layer({"tmc": X_tmc, "ligand": X_ligand})
+    np.testing.assert_allclose(output, np.stack(
+        [
+            np.concatenate([X_tmc, X_ligand[:, 0], X_ligand[:, 1]], axis=-1),
+            np.concatenate([X_tmc, X_ligand[:, 1], X_ligand[:, 0]], axis=-1),
+        ], axis=1)
+    )
+
+
+def test_permutational_nn():
+    permutations = [
+        (0, 1),
+        (1, 0),
+    ]
+
+    model = tf.keras.Sequential([
+        PermutationLayer(permutations=permutations),
+        tf.keras.layers.Dense(1),
+        # Sum over the permuations
+        tf.keras.layers.Lambda(lambda x: tf.reduce_sum(x, axis=1)),
+    ])
+
+    rng = np.random.default_rng(0)
+    X_tmc = rng.normal(1.2, 0.4, size=(10, 4))
+    X_ligand = rng.normal(1.1, 0.5, size=(10, 2, 4))
+
+    input = {"tmc": X_tmc, "ligand": X_ligand}
+    input_permuted = {"tmc": X_tmc, "ligand": X_ligand[:, [1, 0]]}
+    assert model(input).shape == (10, 1)
+    np.testing.assert_allclose(model(input), model(input_permuted))

tests/runtest.py

@@ -0,0 +1,10 @@
+from molSimplify.Scripts.generator import startgen
+
+
+def runtest(resource_path_root):
+    infile = resource_path_root / "inputs" / "example_1_noff.in"
+    args = ['main.py', '-i', infile]
+    startgen(args, False, False)
+    infile = resource_path_root / "inputs" / "example_1.in"
+    args = ['main.py', '-i', infile]
+    startgen(args, False, False)

tests/test_Mol2D.py

@@ -0,0 +1,128 @@
+import pytest
+from molSimplify.Classes.mol2D import Mol2D
+
+
+def water_Mol2D():
+    mol = Mol2D()
+    mol.add_nodes_from(
+        [(0, {"symbol": "O"}), (1, {"symbol": "H"}), (2, {"symbol": "H"})]
+    )
+    mol.add_edges_from([(0, 1), (0, 2)])
+    return mol
+
+
+def furan_Mol2D():
+    mol = Mol2D()
+    mol.add_nodes_from(
+        [
+            (0, {"symbol": "O"}),
+            (1, {"symbol": "C"}),
+            (2, {"symbol": "C"}),
+            (3, {"symbol": "C"}),
+            (4, {"symbol": "C"}),
+            (5, {"symbol": "H"}),
+            (6, {"symbol": "H"}),
+            (7, {"symbol": "H"}),
+            (8, {"symbol": "H"}),
+        ]
+    )
+    mol.add_edges_from(
+        [(0, 1), (1, 2), (2, 3), (3, 4), (0, 4), (1, 5), (2, 6), (3, 7), (4, 8)]
+    )
+    return mol
+
+
+def acac_Mol2D():
+    mol = Mol2D()
+    mol.add_nodes_from(
+        [
+            (0, {"symbol": "O"}),
+            (1, {"symbol": "C"}),
+            (2, {"symbol": "C"}),
+            (3, {"symbol": "C"}),
+            (4, {"symbol": "C"}),
+            (5, {"symbol": "O"}),
+            (6, {"symbol": "C"}),
+            (7, {"symbol": "H"}),
+            (8, {"symbol": "H"}),
+            (9, {"symbol": "H"}),
+            (10, {"symbol": "H"}),
+            (11, {"symbol": "H"}),
+            (12, {"symbol": "H"}),
+            (13, {"symbol": "H"}),
+        ]
+    )
+    mol.add_edges_from(
+        [(0, 1), (1, 2), (1, 3), (2, 7), (2, 8), (2, 9), (3, 4),
+         (3, 10), (4, 5), (4, 6), (6, 11), (6, 12), (6, 13)]
+    )
+    return mol
+
+
+@pytest.mark.parametrize(
+    "mol, ref",
+    [
+        (water_Mol2D(), "Mol2D(O1H2)"),
+        (furan_Mol2D(), "Mol2D(O1C4H4)"),
+        (acac_Mol2D(), "Mol2D(O2C5H7)"),
+    ])
+def test_Mol2D_repr(mol, ref):
+    assert mol.__repr__() == ref
+
+
+@pytest.mark.parametrize(
+    "name, smiles, mol_ref",
+    [
+        ("water", "O", water_Mol2D()),
+        ("furan", "o1cccc1", furan_Mol2D()),
+        ("acac", "[O-]-C(C)=CC(=O)C", acac_Mol2D()),
+    ]
+)
+def test_Mol2D_constructors(resource_path_root, name, smiles, mol_ref):
+    # From mol file
+    mol = Mol2D.from_mol_file(resource_path_root / "inputs" / "io" / f"{name}.mol")
+
+    assert mol.nodes == mol_ref.nodes
+    assert mol.edges == mol_ref.edges
+
+    # From mol2 file
+    mol = Mol2D.from_mol2_file(resource_path_root / "inputs" / "io" / f"{name}.mol2")
+
+    assert mol.nodes == mol_ref.nodes
+    assert mol.edges == mol_ref.edges
+
+    # From smiles
+    mol = Mol2D.from_smiles(smiles)
+
+    assert mol.nodes == mol_ref.nodes
+    assert mol.edges == mol_ref.edges
+
+
+@pytest.mark.parametrize(
+    "filename, node_hash_ref, edge_hash_ref, graph_det_ref",
+    [
+        ("water.mol2", "2c96eb4288d63b2a9437ddd4172e67f3", "e5206dd18f7e829cf77fae1a48e7b0b9", "-507.9380086"),
+        ("formaldehyde.mol2", "e4af80ed7395aef9001d1b170c5c0ec6", "df21357bb47fe3aa2e062c7e3a3b573e", "-42043.85450"),
+        ("furan.mol2", "f6090276d7369c0c0a535113ec1d97cf", "a9b6fbc7b5f53613546d5e91a7544ed6", "-19404698740"),
+        ("acac.mol2", "0dfc6836e022406f1be7b5627451d590", "d4879258a3a6c832b55b2e9d7387f96d", "-2.822252628e+16"),
+        ("ADUYUV.mol2", "e134585068e342d12364850112ec7609", "9bc68a69bfeceabffe878084da72f542", "2.7503745443e+80"),
+    ]
+)
+def test_Mol2D_graph_hash(resource_path_root, filename, node_hash_ref, edge_hash_ref, graph_det_ref):
+    # From mol file
+    mol = Mol2D.from_mol2_file(resource_path_root / "inputs" / "io" / filename)
+
+    node_hash = mol.graph_hash()
+    edge_hash = mol.graph_hash_edge_attr()
+    graph_det = mol.graph_determinant()
+
+    assert node_hash == node_hash_ref
+    assert edge_hash == edge_hash_ref
+    assert graph_det == graph_det_ref
+
+
+def test_find_metal(resource_path_root):
+    mol = Mol2D.from_mol2_file(resource_path_root / "inputs" / "io" / "ADUYUV.mol2")
+    metals = mol.find_metal()
+
+    assert metals == [35]