digichem-core 6.0.0rc1__py3-none-any.whl

digichem/test/test_image.py

@@ -0,0 +1,337 @@
+import pytest
+from pathlib import Path
+import shutil
+
+from digichem.image.excited_states import Excited_states_diagram_maker
+from digichem.image.graph import Convergence_graph_maker
+from digichem.image.orbitals import Orbital_diagram_maker
+from digichem.image.spectroscopy import Absorption_graph_maker, Emission_graph_maker, \
+    Frequency_graph_maker, NMR_graph_maker, NMR_graph_zoom_maker
+from digichem.image.structure import Skeletal_image_maker
+from digichem.image.vmd import Structure_image_maker, Orbital_image_maker, Density_image_maker, \
+    Combined_orbital_image_maker, Permanent_dipole_image_maker, Transition_dipole_image_maker
+from digichem.parse.util import open_for_parsing, parse_calculation
+
+from digichem.test.util import digichem_options, data_directory
+from digichem.test.test_result import gaussian_ES_result, turbomole_ES_result, orca_ES_result, \
+    gaussian_opt_result, turbomole_opt_result, orca_opt_result, orca_opt_freq_result, \
+    orca_nmr_result
+
+HAS_VMD = shutil.which("vmd")
+
+@pytest.mark.parametrize("result_set", [
+    pytest.lazy_fixture("gaussian_ES_result"),
+    pytest.lazy_fixture("turbomole_ES_result"),
+    pytest.lazy_fixture("orca_ES_result")
+])
+def test_es_diagram(result_set, tmp_path, digichem_options):
+    """Can we make an excited states diagram?"""
+    maker = Excited_states_diagram_maker.from_options(
+        tmp_path / "tmp.png",
+        excited_states = result_set.excited_states,
+        ground_state = result_set.ground_state,
+        options = digichem_options
+    )
+
+    maker.get_image()
+    assert Path(tmp_path, "tmp.png").exists()
+
+
+@pytest.mark.parametrize("result_set", [
+    pytest.lazy_fixture("gaussian_opt_result"),
+    pytest.lazy_fixture("turbomole_opt_result"),
+    pytest.lazy_fixture("orca_opt_result")
+])
+def test_convergence_diagram(result_set, tmp_path, digichem_options):
+    """Can we make an optimisation graph?"""
+    maker = Convergence_graph_maker.from_options(
+        tmp_path / "tmp.png",
+        energies = result_set.energies.scf,
+        options = digichem_options
+    )
+
+    maker.get_image()
+    assert Path(tmp_path, "tmp.png").exists()
+
+
+@pytest.mark.parametrize("result_set", [
+    pytest.lazy_fixture("gaussian_opt_result"),
+    pytest.lazy_fixture("turbomole_opt_result"),
+    pytest.lazy_fixture("orca_opt_result")
+])
+def test_orbital_diagram(result_set, tmp_path, digichem_options):
+    """Can we make an orbital diagram?"""
+    maker = Orbital_diagram_maker.from_options(
+        tmp_path / "tmp.png",
+        orbitals = result_set.orbitals,
+        options = digichem_options
+    )
+
+    maker.get_image()
+    assert Path(tmp_path, "tmp.png").exists()
+
+
+@pytest.mark.parametrize("result_set", [
+    pytest.lazy_fixture("gaussian_ES_result"),
+    pytest.lazy_fixture("turbomole_ES_result"),
+    pytest.lazy_fixture("orca_ES_result")
+])
+def test_abs_diagram(result_set, tmp_path, digichem_options):
+    """Can we make an absorption spectrum?"""
+    maker = Absorption_graph_maker.from_options(
+        tmp_path / "tmp.png",
+        excited_states = result_set.excited_states,
+        options = digichem_options
+    )
+
+    maker.get_image()
+    assert Path(tmp_path, "tmp.png").exists()
+
+
+@pytest.mark.parametrize("result_set", [
+    pytest.lazy_fixture("gaussian_ES_result"),
+    pytest.lazy_fixture("turbomole_ES_result"),
+    pytest.lazy_fixture("orca_ES_result")
+])
+def test_pl_diagram(result_set, tmp_path, digichem_options):
+    """Can we make an emission spectrum?"""
+    maker = Emission_graph_maker.from_options(
+        tmp_path / "tmp.png",
+        excited_states = result_set.excited_states,
+        options = digichem_options
+    )
+
+    maker.get_image()
+    assert Path(tmp_path, "tmp.png").exists()
+
+
+@pytest.mark.parametrize("result_set", [
+    pytest.lazy_fixture("gaussian_opt_result"),
+    pytest.lazy_fixture("turbomole_opt_result"),
+    pytest.lazy_fixture("orca_opt_freq_result")
+])
+def test_freq_diagram(result_set, tmp_path, digichem_options):
+    """Can we make an IR spectrum?"""
+    maker = Frequency_graph_maker.from_options(
+        tmp_path / "tmp.png",
+        vibrations = result_set.vibrations,
+        options = digichem_options
+    )
+
+    maker.get_image()
+    assert Path(tmp_path, "tmp.png").exists()
+
+
+@pytest.mark.parametrize("result_set", [
+    pytest.lazy_fixture("orca_nmr_result"),
+])
+def test_nmr_diagram(result_set, tmp_path, digichem_options):
+    """Can we make an NMR spectrum?"""
+    # Get a suitable spectrometer object.
+    spectrometer = result_set.nmr.spectrometer
+
+    maker = NMR_graph_maker.from_options(
+        tmp_path / "tmp.png",
+        graph = spectrometer.get_graph(1, 1),
+        options = digichem_options
+    )
+
+    maker.get_image()
+    assert Path(tmp_path, "tmp.png").exists()
+
+
+@pytest.mark.parametrize("result_set", [
+    pytest.lazy_fixture("orca_nmr_result"),
+])
+def test_focus_nmr_diagram(result_set, tmp_path, digichem_options):
+    """Can we make an NMR spectrum?"""
+    # Get a suitable spectrometer object.
+    spectrometer = result_set.nmr.spectrometer
+
+    maker = NMR_graph_zoom_maker.from_options(
+        tmp_path / "tmp.png",
+        graph = spectrometer.get_graph(1, 1),
+        focus = result_set.atoms.groups[(2, "H")],
+        options = digichem_options
+    )
+
+    maker.get_image()
+    assert Path(tmp_path, "tmp.png").exists()
+
+
+@pytest.mark.parametrize("result_set", [
+    pytest.lazy_fixture("gaussian_opt_result"),
+    pytest.lazy_fixture("turbomole_opt_result"),
+    pytest.lazy_fixture("orca_opt_freq_result")
+])
+def test_2d_diagram(result_set, tmp_path, digichem_options):
+    """Can we make an IR spectrum?"""
+    maker = Skeletal_image_maker.from_options(
+        tmp_path / "tmp.png",
+        atoms = result_set.atoms,
+        options = digichem_options
+    )
+
+    maker.get_image()
+    assert Path(tmp_path, "tmp.png").exists()
+
+
+@pytest.mark.skipif(not HAS_VMD,
+                    reason="No VMD available")
+@pytest.mark.parametrize("cube_file", [
+    Path(data_directory(), "Cubes/Pyridine.HOMO.cube")
+], ids = ["Gaussian"])
+@pytest.mark.parametrize("maker_cls", [
+    Structure_image_maker,
+    Orbital_image_maker,
+])
+def test_3d_image(cube_file, maker_cls, tmp_path, digichem_options):
+    """Can we make a 3D structure image?"""
+    maker = maker_cls.from_options(
+        tmp_path / "tmp.png",
+        cube_file = cube_file,
+        options = digichem_options
+    )
+
+    maker.get_file('x0y0z0')
+    assert Path(tmp_path, "tmp.x0y0z0.png").exists()
+
+
+# @pytest.mark.parametrize("result_path", [
+#     Path(data_directory(), "Pyridine/Gaussian 16 Optimisation Frequencies PBE1PBE (GD3BJ) Toluene 6-31G(d,p).tar.gz")
+# ], ids = ["Gaussian"])
+# @pytest.mark.parametrize("density", [
+#     "SCF"
+# ])
+
+@pytest.mark.skipif(not HAS_VMD,
+                    reason="No VMD available")
+@pytest.mark.parametrize("cube_file", [
+    Path(data_directory(), "Cubes/Pyridine.SCF.cube")
+], ids = ["Gaussian"])
+def test_density_image(cube_file, tmp_path, digichem_options):
+    """Can we make a 3D structure image?"""
+    maker = Density_image_maker.from_options(
+        tmp_path / "tmp.png",
+        cube_file = cube_file,
+        options = digichem_options
+    )
+
+    maker.get_file('x0y0z0')
+    assert Path(tmp_path, "tmp.x0y0z0.png").exists()
+
+
+@pytest.mark.skipif(not HAS_VMD,
+                    reason="No VMD available")
+@pytest.mark.parametrize("cube_file", [
+    Path(data_directory(), "Cubes/Benzene.anion.spin.cube")
+], ids = ["Gaussian"])
+def test_spin_density_image(cube_file, tmp_path, digichem_options):
+    """Can we make a 3D structure image?"""
+    maker = Density_image_maker.from_options(
+        tmp_path / "tmp.png",
+        cube_file = cube_file,
+        options = digichem_options
+    )
+
+    maker.get_file('x0y0z0')
+    assert Path(tmp_path, "tmp.x0y0z0.png").exists()
+
+
+@pytest.mark.skipif(not HAS_VMD,
+                    reason="No VMD available")
+@pytest.mark.parametrize("homo_cube, lumo_cube", [
+    [Path(data_directory(), "Cubes/Pyridine.HOMO.cube"), Path(data_directory(), "Cubes/Pyridine.LUMO.cube")]
+], ids = ["Gaussian"])
+def test_combined_orbital_image(homo_cube, lumo_cube, tmp_path, digichem_options):
+    """Can we make a 3D structure image?"""
+    maker = Combined_orbital_image_maker.from_options(
+        tmp_path / "tmp.png",
+        HOMO_cube_file = homo_cube,
+        LUMO_cube_file = lumo_cube,
+        options = digichem_options
+    )
+
+    maker.get_file('x0y0z0')
+    assert Path(tmp_path, "tmp.x0y0z0.png").exists()
+
+
+@pytest.mark.skipif(not HAS_VMD,
+                    reason="No VMD available")
+@pytest.mark.parametrize("cube_file", [
+    Path(data_directory(), "Cubes/Benzene.anion.AHOMO.cube")
+], ids = ["Gaussian"])
+def test_unrestricted_orbital_image(cube_file, tmp_path, digichem_options):
+    """Can we make a 3D structure image?"""
+    maker = Orbital_image_maker.from_options(
+        tmp_path / "tmp.png",
+        cube_file = cube_file,
+        options = digichem_options
+    )
+
+    maker.get_file('x0y0z0')
+    assert Path(tmp_path, "tmp.x0y0z0.png").exists()
+
+
+@pytest.mark.skipif(not HAS_VMD,
+                    reason="No VMD available")
+@pytest.mark.parametrize("result_path, cube_file", [
+    [  
+        Path(data_directory(), "Pyridine/Gaussian 16 Optimisation Frequencies PBE1PBE (GD3BJ) Toluene 6-31G(d,p).tar.gz"),
+        Path(data_directory(), "Cubes/Pyridine.HOMO.cube"),
+    ]
+])
+def test_pdm_image(result_path, cube_file, tmp_path, digichem_options):
+    """Can we make a 3D structure image?"""
+    with open_for_parsing(result_path) as open_files:
+        result_set = parse_calculation(*open_files, options = digichem_options)
+        maker = Permanent_dipole_image_maker.from_options(
+            tmp_path / "tmp.png",
+            cube_file = cube_file,
+            dipole_moment = result_set.dipole_moment,
+            options = digichem_options
+        )
+
+        maker.get_file('x0y0z0')
+        assert Path(tmp_path, "tmp.x0y0z0.png").exists()
+
+
+@pytest.mark.skipif(not HAS_VMD,
+                    reason="No VMD available")
+@pytest.mark.parametrize("result_path, cube_file", [
+    [
+        Path(data_directory(), "Pyridine/Gaussian 16 Excited States TDA Optimised S(1) PBE1PBE (GD3BJ) Toluene 6-31G(d,p).tar.gz"),
+        Path(data_directory(), "Cubes/Pyridine.HOMO.cube"),
+    ]
+])
+def test_tdm_image(result_path, cube_file, tmp_path, digichem_options):
+    """Can we make a 3D structure image?"""
+    with open_for_parsing(result_path) as open_files:
+        result_set = parse_calculation(*open_files, options = digichem_options)
+        maker = Transition_dipole_image_maker.from_options(
+            tmp_path / "tmp.png",
+            cube_file = cube_file,
+            dipole_moment = result_set.excited_states.find("S(1)").transition_dipole_moment.electric,
+            magnetic_dipole_moment = result_set.excited_states.find("S(1)").transition_dipole_moment.magnetic,
+            options = digichem_options
+        )
+
+        maker.get_file('x0y0z0')
+        assert Path(tmp_path, "tmp.x0y0z0.png").exists()
+
+
+@pytest.mark.skipif(not HAS_VMD,
+                    reason="No VMD available")
+@pytest.mark.parametrize("cube_file", [
+    Path(data_directory(), "Cubes/Pyridine.HOMO.cube"),
+])
+def test_nto_image(cube_file, tmp_path, digichem_options):
+    """Can we make a 3D structure image?"""
+    maker = Orbital_image_maker.from_options(
+        tmp_path / "tmp.png",
+        cube_file = cube_file,
+        options = digichem_options
+    )
+
+    maker.get_file('x0y0z0')
+    assert Path(tmp_path, "tmp.x0y0z0.png").exists()

digichem/test/test_input.py

@@ -0,0 +1,64 @@
+"""Tests for parsing input files"""
+
+import pytest
+from pathlib import Path
+
+from digichem.test.util import pyridine_si_v2, pyridine_si_v1, pyridine_cml,\
+    result_files
+from digichem.input.digichem_input import si_from_file
+
+@pytest.mark.parametrize("file_path", [
+        pyridine_si_v2,
+        pyridine_si_v1
+     ])
+def test_input_reading(file_path):
+    """
+    Test whether we can correctly read from an existing si file.
+    """
+    si_file = si_from_file(file_path)
+    
+    # Check charge and mult.
+    assert si_file.charge == 0
+    assert si_file.multiplicity == 1
+    
+    # Check geometry.
+    # All files should contain data for pyridine.
+    assert len(si_file.atoms) == 11
+    assert str(si_file.formula) == "NC5H5"
+
+
+def test_si_writing(tmp_path):
+    """
+    Test whether we can correctly write a new .si file.
+    """
+    # Read in an input file.
+    si_file = si_from_file(pyridine_cml)
+    
+    # Write to our temp dir.
+    new_si_path = Path(tmp_path, "Pyrdine.si")
+    with open(new_si_path, "wt") as out_file:
+        si_file.to_file(out_file)
+        
+    # Parse the newly written file.
+    new_si_file = si_from_file(new_si_path)
+    
+    # Check they're the same.
+    assert new_si_file == si_file
+
+
+@pytest.mark.parametrize("file_path, sha", [
+        [result_files['gaussian'][0], "ebd4f4e9f81cdb57ec2d2f2e1fba9cef0698f4c0"],
+        [result_files['turbomole'][0], "60a8ebd9e701b849cfccd9cbb41684519a7fdf0b"],
+        [result_files['orca'][0], "e48e7f653f4e67c1bd4c5c4bb76405fad2d441d0"],
+     ])
+def test_input_history(file_path, sha):
+    """
+    Test whether the history attribute is set properly.
+    """
+    si_file = si_from_file(file_path)
+    
+    assert si_file.history == sha
+    
+    dump = si_file.dict
+    
+    assert dump['history'] == sha

digichem/test/test_parsing.py

@@ -0,0 +1,79 @@
+"""Tests for result parsing and processing"""
+
+from pathlib import Path
+import itertools
+import numpy
+import pytest
+import yaml
+
+from digichem.parse import parse_calculation, parse_multiple_calculations, parse_and_merge_calculations
+from digichem.test.util import data_directory, result_files, digichem_options
+from digichem.result import Result_set
+
+@pytest.mark.parametrize("result_data", list(itertools.chain(*list(result_files.values()))))
+def test_parsing(result_data, digichem_options):
+    """Test whether we can parse various calc results."""
+    result = parse_calculation(result_data, options = digichem_options)
+    assert isinstance(result, Result_set)
+
+        
+def test_multi_parsing(digichem_options):
+    """Test whether we can parse in parallel."""
+    
+    results = parse_multiple_calculations(*list(itertools.chain(*list(result_files.values()))), options = digichem_options)
+    
+    # Check length.
+    assert len(results) == len(list(itertools.chain(*list(result_files.values()))))
+
+
+@pytest.mark.parametrize("data_set", list(result_files.values()))
+def test_merged_parsing(data_set, digichem_options):
+    """Test whether we can parse and merge calc results."""
+    result = parse_and_merge_calculations(*data_set, options = digichem_options)
+    
+    assert isinstance(result, Result_set)
+    assert len(result.results) == len(data_set)
+
+
+@pytest.mark.parametrize(
+    "result_files",
+    itertools.chain(
+        [(result_file,) for program_files in result_files.values() for result_file in program_files],
+        [(
+            Path(data_directory(), "Naphthalene/Gaussian 16 Optimisation Frequencies PBE1PBE (GD3BJ) Toluene 6-31G(d,p)"),
+            Path(data_directory(), "Naphthalene/Gaussian 16 Excited States TDA Optimised S(1) PBE1PBE (GD3BJ) Toluene 6-31G(d,p).tar.gz")
+        )]
+    )
+)
+def test_dump_and_parse(result_files, tmp_path, digichem_options):
+    """Test whether we can dump and reload a result to get the same data back again."""
+    # Set numpy errors (not sure why this isn't the default...)
+    numpy.seterr(invalid = 'raise', divide = 'raise')
+    
+    # Parse the raw data.
+    if len(result_files) == 1:
+        raw = parse_calculation(result_files[0], options = digichem_options)
+    
+    else:
+        raw = parse_and_merge_calculations(*result_files, options = digichem_options)
+    
+    # Instead of just dumping to memory we'll dump to a file to test the full mechanism.
+    with open(Path(tmp_path, "dump.sir"), "wt") as dump_file:
+        dump_file.write(yaml.safe_dump(raw.dump(digichem_options = digichem_options)))
+    
+    # Now load the result back again.
+    parsed = parse_calculation(Path(tmp_path, "dump.sir"), options = digichem_options)
+    
+    # Dump both the raw and parsed result sets and compare to make sure they're the same.
+    raw_dump = raw.dump(digichem_options)
+    parsed_dump = parsed.dump(digichem_options)
+    
+    # Aux files are not preserved, so don't compare these.
+    raw_dump['metadata'].pop("auxiliary_files")
+    raw_dump['metadata'].pop("log_files")
+    parsed_dump['metadata'].pop("auxiliary_files")
+    parsed_dump['metadata'].pop("log_files")
+    
+    
+    assert raw_dump == parsed_dump
+        

digichem/test/test_prattle.py

@@ -0,0 +1,36 @@
+"""Tests for functioning of oprattle"""
+
+import pytest
+
+from digichem.file.prattle import Oprattle_formats, Openprattle_converter
+
+from digichem.test.util import ethane_xyz, benzene_cdx
+
+@pytest.mark.parametrize("readwrite", ["read", "write"])
+def test_formats(readwrite):
+    if readwrite == "read":
+        assert len(Oprattle_formats().read()) > 0
+    
+    else:
+        assert len(Oprattle_formats().write()) > 0
+
+@pytest.mark.parametrize("file_path", [
+    ethane_xyz,
+    benzene_cdx
+])
+def test_convert(file_path):
+    Openprattle_converter(input_file_path = file_path).convert("com")
+
+
+@pytest.mark.parametrize("file_path", [
+    ethane_xyz,
+    benzene_cdx
+])
+def test_gen3d(file_path):
+    first = Openprattle_converter(input_file_path = file_path).convert("xyz", gen3D = False)
+
+    same = Openprattle_converter(input_file_path = file_path).convert("xyz", gen3D = False)
+    different = Openprattle_converter(input_file_path = file_path).convert("xyz", gen3D = True)
+
+    assert first == same
+    assert first != different