def test_compute_gradient(program, model, keywords):
if not has_program(program):
pytest.skip("Program '{}' not found.".format(program))
molecule = _get_molecule(program)
inp = AtomicInput(molecule=molecule,
driver="gradient",
model=model,
extras={"mytag": "something"},
keywords=keywords)
if program in ["adcc", "mrchem"]:
with pytest.raises(qcng.exceptions.InputError) as e:
qcng.compute(inp, program, raise_error=True)
assert "Driver gradient not implemented" in str(e.value)
else:
ret = qcng.compute(inp, program, raise_error=True)
assert ret.success is True
assert isinstance(ret.return_result, np.ndarray)
assert len(ret.return_result.shape) == 2
assert ret.return_result.shape[1] == 3
assert "mytag" in ret.extras, ret.extras
def test_local_options_memory_gib(program, model, keywords, memory_trickery, request):
"""Ensure memory handling implemented in harness (if applicable).
For available harnesses, run minimal calc at specific total node memory, both through runtime
config alone and with clashing (and non-QCEngine-like) keyword spec. Check memory quantity
shows up in ``TaskConfig``.
For ``managed-memory``-active harnesses, check that memory registers in output.
New Harness Instructions
------------------------
* Make sure minimal calc is in _canonical_methods above.
* If ``managed_memory=True`` in harness, add regex to ``stdout_ref`` below to check that memory
is specifiable.
* If this test doesn't work, implement or adjust ``config.memory`` in your harness.
"""
if not has_program(program):
pytest.skip(f"Program '{program}' not found.")
harness = qcng.get_program(program)
molecule = _get_molecule(program, model["method"])
addl_keywords = memory_trickery.get(program, memory_trickery)
use_keywords = {**keywords, **addl_keywords}
# << Config
config = qcng.config.get_config(
hostname="something",
task_config={
"ncores": 1,
"nnodes": 1,
"memory": 1.555,
},
)
# << Run
inp = AtomicInput(molecule=molecule, driver="energy", model=model, keywords=use_keywords)
ret = qcng.compute(inp, program, raise_error=True, local_options=config.dict())
pprint.pprint(ret.dict(), width=200)
assert ret.success is True
# << Reference
stdout_ref = { # 1.555 GiB = 208708567 quad-words
"cfour": "Allocated 1592 MB of main memory",
"gamess": "208000000 WORDS OF MEMORY AVAILABLE",
"nwchem": r"total = 2087085\d\d doubles = 1592.3 Mbytes", # doubles is quad-words. Mbytes is MiB
"psi4": "1592 MiB Core",
}
# << Test
assert config.ncores == 1
assert pytest.approx(config.memory, 0.1) == 1.555
if harness._defaults["managed_memory"] is True:
assert re.search(stdout_ref[program], ret.stdout), f"Memory pattern not found: {stdout_ref[program]}"
def test_compute_bad_models(program, model):
if not testing.has_program(program):
pytest.skip("Program '{}' not found.".format(program))
inp = ResultInput(molecule=qcng.get_molecule("hydrogen"), driver="energy", model=model)
with pytest.raises(ValueError) as exc:
ret = qcng.compute(inp, program, raise_error=True)
def test_compute_gradient(program, model):
if not testing.has_program(program):
pytest.skip("Program '{}' not found.".format(program))
inp = ResultInput(molecule=qcng.get_molecule("hydrogen"), driver="gradient", model=model)
ret = qcng.compute(inp, program, raise_error=True)
assert ret.success is True
assert isinstance(ret.return_result, list)
def test_local_options_ncores(program, model, keywords, ncores):
"""Ensure multithreading implemented in harness (if applicable) or multithreaded runs don't
break harness (if inapplicable).
For available harnesses, run minimal calc with single and multiple cores; check ncores count
shows up in ``TaskConfig``.
For ``thread_parallel``-active harnesses, check ncores count registers in output.
New Harness Instructions
------------------------
* Make sure minimal calc is in _canonical_methods above.
* If ``thread_parallel=True`` in harness, add regex to ``stdout_ref`` below to check ncores the
program sees.
* If this test doesn't work, implement or adjust ``config.ncores`` in your harness.
"""
if not has_program(program):
pytest.skip(f"Program '{program}' not found.")
harness = qcng.get_program(program)
molecule = _get_molecule(program, model["method"])
# << Config
config = qcng.config.get_config(
hostname="something",
task_config={
"ncores": ncores,
"nnodes": 1,
},
)
# << Run
inp = AtomicInput(molecule=molecule, driver="energy", model=model, keywords=keywords)
ret = qcng.compute(inp, program, raise_error=True, local_options=config.dict())
pprint.pprint(ret.dict(), width=200)
assert ret.success is True
# << Reference
stdout_ref = {
"cfour": rf"Running with {ncores} threads/proc",
"gamess": rf"MEMDDI DISTRIBUTED OVER\s+{ncores} PROCESSORS",
# "gamess": rf"PARALLEL VERSION RUNNING ON\s+{ncores} PROCESSORS IN\s+1 NODES", # no line for serial
# nwchem is node_parallel only
"psi4": rf"Threads:\s+{ncores}",
}
# << Test
assert config.ncores == ncores
assert config.nnodes == 1
if harness._defaults["thread_parallel"] is True:
assert re.search(stdout_ref[program], ret.stdout), f"Thread pattern not found: {stdout_ref[program]}"
def test_compute_bad_models(program, model):
if not has_program(program):
pytest.skip("Program '{}' not found.".format(program))
adriver = model.pop("driver", "energy")
amodel = model
inp = AtomicInput(molecule=qcng.get_molecule("hydrogen"), driver=adriver, model=amodel)
with pytest.raises(qcng.exceptions.InputError) as exc:
ret = qcng.compute(inp, program, raise_error=True)
def test_compute_energy(program, model, keywords):
if not has_program(program):
pytest.skip(f"Program '{program}' not found.")
molecule = _get_molecule(program)
inp = AtomicInput(molecule=molecule, driver="energy", model=model, keywords=keywords)
ret = qcng.compute(inp, program, raise_error=True)
assert ret.success is True
assert isinstance(ret.return_result, float)
def test_compute_energy_qcsk_basis(program, model, keywords):
if not has_program(program):
pytest.skip("Program '{}' not found.".format(program))
molecule = _get_molecule(program)
inp = AtomicInput(molecule=molecule, driver="energy", model=model, keywords=keywords)
with pytest.raises(qcng.exceptions.InputError) as e:
qcng.compute(inp, program, raise_error=True)
assert "QCSchema BasisSet for model.basis not implemented" in str(e.value)
def test_compute_energy(program, model):
if not has_program(program):
pytest.skip("Program '{}' not found.".format(program))
inp = AtomicInput(molecule=qcng.get_molecule("hydrogen"),
driver="energy",
model=model)
ret = qcng.compute(inp, program, raise_error=True)
assert ret.success is True
assert isinstance(ret.return_result, float)
def test_compute_gradient(program, model):
if not has_program(program):
pytest.skip("Program '{}' not found.".format(program))
molecule = _get_molecule(program)
inp = AtomicInput(molecule=molecule, driver="gradient", model=model, extras={"mytag": "something"})
ret = qcng.compute(inp, program, raise_error=True)
assert ret.success is True
assert isinstance(ret.return_result, np.ndarray)
assert len(ret.return_result.shape) == 2
assert ret.return_result.shape[1] == 3
assert "mytag" in ret.extras, ret.extras
def test_optimization_submissions(fractal_compute_server, specification):
"""Test submitting an Optimization dataset to a snowflake server."""
client = FractalClient(fractal_compute_server)
qc_spec, driver = specification
program = qc_spec["program"]
if not has_program(program):
pytest.skip(f"Program '{program}' not found.")
molecules = Molecule.from_file(get_data("butane_conformers.pdb"), "pdb")
factory = OptimizationDatasetFactory(driver=driver)
factory.add_qc_spec(**qc_spec,
spec_name="default",
spec_description="test",
overwrite=True)
dataset = factory.create_dataset(
dataset_name=f"Test optimizations info {program}, {driver}",
molecules=molecules[:2],
description="Test optimization dataset",
tagline="Testing optimization datasets",
)
with pytest.raises(DatasetInputError):
dataset.submit(client=client, await_result=False)
# now add a mock url so we can submit the data
dataset.metadata.long_description_url = "https://test.org"
# now submit again
dataset.submit(client=client, await_result=False)
fractal_compute_server.await_results()
# make sure of the results are complete
ds = client.get_collection("OptimizationDataset", dataset.dataset_name)
# check the metadata
meta = Metadata(**ds.data.metadata)
assert meta == dataset.metadata
# check the provenance
assert dataset.provenance == ds.data.provenance
# check the qc spec
for qc_spec in dataset.qc_specifications.values():
spec = ds.data.specs[qc_spec.spec_name]
assert spec.description == qc_spec.spec_description
assert spec.qc_spec.driver == dataset.driver
assert spec.qc_spec.method == qc_spec.method
assert spec.qc_spec.basis == qc_spec.basis
assert spec.qc_spec.program == qc_spec.program
# check the keywords
keywords = client.query_keywords(spec.qc_spec.keywords)[0]
assert keywords.values["maxiter"] == dataset.maxiter
assert keywords.values["scf_properties"] == dataset.scf_properties
# query the dataset
ds.query(qc_spec.spec_name)
for index in ds.df.index:
record = ds.df.loc[index].default
assert record.status.value == "COMPLETE"
assert record.error is None
assert len(record.trajectory) > 1
# if we used psi4 make sure the properties were captured
if program == "psi4":
result = record.get_trajectory()[0]
assert "CURRENT DIPOLE X" in result.extras["qcvars"].keys()
assert "SCF QUADRUPOLE XX" in result.extras["qcvars"].keys()
def test_basic_submissions_single_pcm_spec(fractal_compute_server):
"""Test submitting a basic dataset to a snowflake server with pcm water in the specification."""
client = FractalClient(fractal_compute_server)
program = "psi4"
if not has_program(program):
pytest.skip(f"Program '{program}' not found.")
molecules = Molecule.from_file(get_data("butane_conformers.pdb"), "pdb")
factory = BasicDatasetFactory(driver="energy")
factory.add_qc_spec(method="hf",
basis="sto-3g",
program=program,
spec_name="default",
spec_description="testing the single points with pcm",
implicit_solvent=PCMSettings(units="au",
medium_Solvent="water"),
overwrite=True)
# only use one molecule due to the time it takes to run with pcm
dataset = factory.create_dataset(
dataset_name=f"Test single points with pcm water",
molecules=molecules[0],
description="Test basics dataset with pcm water",
tagline="Testing single point datasets with pcm water",
)
with pytest.raises(DatasetInputError):
dataset.submit(client=client, await_result=False)
# now add a mock url so we can submit the data
dataset.metadata.long_description_url = "https://test.org"
# now submit again
dataset.submit(client=client, await_result=False)
fractal_compute_server.await_results()
# make sure of the results are complete
ds = client.get_collection("Dataset", dataset.dataset_name)
# check the metadata
meta = Metadata(**ds.data.metadata)
assert meta == dataset.metadata
assert ds.data.description == dataset.description
assert ds.data.tagline == dataset.dataset_tagline
assert ds.data.tags == dataset.dataset_tags
# check the provenance
assert dataset.provenance == ds.data.provenance
# check the qc spec
assert ds.data.default_driver == dataset.driver
# get the last ran spec
for specification in ds.data.history:
driver, program, method, basis, spec_name = specification
spec = dataset.qc_specifications[spec_name]
assert driver == dataset.driver
assert program == spec.program
assert method == spec.method
assert basis == spec.basis
break
else:
raise RuntimeError(
f"The requested compute was not found in the history {ds.data.history}"
)
for spec in dataset.qc_specifications.values():
query = ds.get_records(
method=spec.method,
basis=spec.basis,
program=spec.program,
)
for index in query.index:
result = query.loc[index].record
assert result.status.value.upper() == "COMPLETE"
assert result.error is None
assert result.return_result is not None
# make sure the PCM result was captured
assert result.extras["qcvars"]["PCM POLARIZATION ENERGY"] < 0
def test_protocol_native(program, model, keywords, native):
"""Ensure native_files protocol implemented in harness.
For harnesses, run minimal gradient calc with different protocol settings; check expected
native/DSL files show up in ``AtomicResult``.
New Harness Instructions
------------------------
* Make sure minimal calc is in _canonical_methods above. This uses gradient for more files.
* Add regex to ``input_ref`` & ``all_ref`` below to check content of input and any other file.
* If this test doesn't work, implement or adjust ``native_files`` in your harness.
"""
if not has_program(program):
pytest.skip(f"Program '{program}' not found.")
harness = qcng.get_program(program)
molecule = _get_molecule(program, model["method"])
# << Config
protocols = {
"native_files": native,
}
config = qcng.config.get_config(
hostname="something",
local_options={
"ncores": 1,
"nnodes": 1,
},
)
# << Run
inp = AtomicInput(molecule=molecule,
driver="gradient",
model=model,
keywords=keywords,
protocols=protocols)
ret = qcng.compute(inp,
program,
raise_error=True,
local_options=config.dict())
pprint.pprint(ret.dict(), width=200)
assert ret.success is True
# << Reference
input_ref = {
"cfour": rf"\*CFOUR\(BASIS=6-31G",
"dftd3": rf"1.000000 1.261000 1.703000",
"gamess": rf"\$basis gbasis=n31 ngauss=6 \$end",
"gcp": rf"level HF3C",
"mctc-gcp": rf"level DFT/SV",
"mp2d": rf"--TT_a1=0.944 --TT_a2=0.48",
"nwchem": rf"H library 6-31G",
"psi4": rf'"driver": "gradient",',
}
all_ref = {
"cfour": ("GRD", rf"1.0+\s+0.0+\s+0.0+\s+0.03"),
"dftd3": ("dftd3_geometry.xyz", rf"H\s+0.0+\s+0.0+\s+0.34"),
"gamess": ("gamess.dat", rf"CLOSED SHELL ORBITALS --- GENERATED AT"),
"gcp": ("gcp_geometry.xyz", rf"H\s+0.0+\s+0.0+\s+0.34"),
"mctc-gcp": ("gcp_geometry.xyz", rf"H\s+0.0+\s+0.0+\s+0.34"),
"mp2d": ("mp2d_geometry", rf"H\s+0.0+\s+0.0+\s+0.34"),
"nwchem": ("nwchem.grad", rf"0.0, 0.0, 0.03"),
"psi4": ("psi4.grad", rf"1.0+\s+(-?)0.0+\s+(-?)0.0+\s+0.03"),
}
# << Test
if native == "none":
assert ret.native_files is None
elif native == "input":
assert list(ret.native_files.keys()) == ["input"]
if ret.native_files:
assert "stdout" not in ret.native_files, f"Stdout found in native_files -- clean up the harness"
assert "stderr" not in ret.native_files, f"Stderr found in native_files -- clean up the harness"
assert "outfiles" not in ret.extras, f"Outfiles found in extras -- clean up the harness"
if native in ["input", "all"]:
assert re.search(
input_ref[program], ret.native_files["input"]
), f"Input file pattern not found: {input_ref[program]}"
if native == "all" and program != "psi4": # allow psi4 once native_files PR merged
fl, snip = all_ref[program]
assert re.search(snip, ret.native_files[fl]
), f"Ancillary file pattern not found in {fl}: {snip}"
def test_local_options_scratch(program, model, keywords):
"""Ensure scratch handling implemented in harness (if applicable).
For available harnesses, run minimal calc at specific scratch directory name (randomly generated
during test) and skip scratch clean-up. Check scratch settings show up in ``TaskConfig``.
For ``scratch``-active harnesses, check that an expected file is written to and left behind in
scratch directory. Check any scratch-related printing in output.
New Harness Instructions
------------------------
* Make sure minimal calc is in _canonical_methods above.
* If ``scratch=True`` in harness, add single file (preferrably output) glob to ``scratch_sample``
below to check that program scratch is directable.
* If ``scratch=True`` in harness, if scratch directory mentioned in output, add regex to
``stdout_ref`` below to check that program scratch is directable. Otherwise, add an
always-passing regex.
* If this test doesn't work, implement or adjust ``config.scratch_directory`` and
``config.scratch_messy`` in your harness.
"""
if not has_program(program):
pytest.skip(f"Program '{program}' not found.")
harness = qcng.get_program(program)
molecule = _get_molecule(program, model["method"])
# << Config
scratch_directory = tempfile.mkdtemp(suffix="_" + program)
config = qcng.config.get_config(
hostname="something",
local_options={
"scratch_directory": scratch_directory,
"scratch_messy": True,
},
)
# << Run
inp = AtomicInput(molecule=molecule,
driver="energy",
model=model,
keywords=keywords)
ret = qcng.compute(inp,
program,
raise_error=True,
local_options=config.dict())
pprint.pprint(ret.dict(), width=200)
assert ret.success is True
# << Reference
stdout_ref = {
"cfour": "University of Florida", # freebie
"dftd3": "Grimme", # freebie
"gamess": "IOWA STATE UNIVERSITY", # freebie
"gcp": "Grimme", # freebie
"mctc-gcp": "Grimme", # freebie
"mp2d": "Beran", # freebie
"nwchem": "E. Apra", # freebie
"psi4": rf"Scratch directory: {scratch_directory}/tmp\w+_psi_scratch/",
}
# a scratch file (preferrably output) expected after job if scratch not cleaned up
scratch_sample = {
"cfour": "*/NEWFOCK",
"dftd3": "*/dftd3_geometry.xyz", # no outfiles
"gamess": "*/gamess.dat",
"gcp": "*/gcp_geometry.xyz", # no outfiles
"mctc-gcp": "*/gcp_geometry.xyz", # no outfiles
"mp2d": "*/mp2d_geometry", # no outfiles
"nwchem": "*/nwchem.db",
"psi4": "*/psi.*.35",
}
# << Test
assert config.scratch_directory.endswith(program)
if harness._defaults["scratch"] is True:
sample_file = list(
Path(scratch_directory).glob(scratch_sample[program]))
assert len(
sample_file
) == 1, f"Scratch sample not found: {scratch_sample[program]} in {scratch_directory}"
assert re.search(
stdout_ref[program],
ret.stdout), f"Scratch pattern not found: {stdout_ref[program]}"
def test_torsiondrive_submissions(fractal_compute_server, specification):
"""
Test submitting a torsiondrive dataset and computing it.
"""
client = FractalClient(fractal_compute_server)
qc_spec, driver = specification
program = qc_spec["program"]
if not has_program(program):
pytest.skip(f"Program '{program}' not found.")
molecules = Molecule.from_smiles("CO")
factory = TorsiondriveDatasetFactory(driver=driver)
factory.add_qc_spec(**qc_spec,
spec_name="default",
spec_description="test",
overwrite=True)
dataset = factory.create_dataset(
dataset_name=f"Test torsiondrives info {program}, {driver}",
molecules=molecules,
description="Test torsiondrive dataset",
tagline="Testing torsiondrive datasets",
)
with pytest.raises(DatasetInputError):
dataset.submit(client=client, await_result=False)
# now add a mock url so we can submit the data
dataset.metadata.long_description_url = "https://test.org"
# now submit again
dataset.submit(client=client, await_result=False)
fractal_compute_server.await_services(max_iter=50)
# make sure of the results are complete
ds = client.get_collection("TorsionDriveDataset", dataset.dataset_name)
# check the metadata
meta = Metadata(**ds.data.metadata)
assert meta == dataset.metadata
# check the provenance
assert dataset.provenance == ds.data.provenance
# check the qc spec
for qc_spec in dataset.qc_specifications.values():
spec = ds.data.specs[qc_spec.spec_name]
assert spec.description == qc_spec.spec_description
assert spec.qc_spec.driver == dataset.driver
assert spec.qc_spec.method == qc_spec.method
assert spec.qc_spec.basis == qc_spec.basis
assert spec.qc_spec.program == qc_spec.program
# check the keywords
keywords = client.query_keywords(spec.qc_spec.keywords)[0]
assert keywords.values["maxiter"] == dataset.maxiter
assert keywords.values["scf_properties"] == dataset.scf_properties
# query the dataset
ds.query(qc_spec.spec_name)
for index in ds.df.index:
record = ds.df.loc[index].default
# this will take some time so make sure it is running with no error
assert record.status.value == "COMPLETE", print(record.dict())
assert record.error is None
assert len(record.final_energy_dict) == 24
def test_optimization_submissions_with_pcm(fractal_compute_server):
"""Test submitting an Optimization dataset to a snowflake server with PCM."""
client = FractalClient(fractal_compute_server)
program = "psi4"
if not has_program(program):
pytest.skip(f"Program '{program}' not found.")
# use a single small molecule due to the extra time PCM takes
molecules = Molecule.from_smiles("C")
factory = OptimizationDatasetFactory(driver="gradient")
factory.add_qc_spec(method="hf",
basis="sto-3g",
program=program,
spec_name="default",
spec_description="test",
implicit_solvent=PCMSettings(units="au",
medium_Solvent="water"),
overwrite=True)
dataset = factory.create_dataset(
dataset_name=f"Test optimizations info with pcm water",
molecules=molecules,
description="Test optimization dataset",
tagline="Testing optimization datasets",
)
with pytest.raises(DatasetInputError):
dataset.submit(client=client, await_result=False)
# now add a mock url so we can submit the data
dataset.metadata.long_description_url = "https://test.org"
# now submit again
dataset.submit(client=client, await_result=False)
fractal_compute_server.await_results()
# make sure of the results are complete
ds = client.get_collection("OptimizationDataset", dataset.dataset_name)
# check the metadata
meta = Metadata(**ds.data.metadata)
assert meta == dataset.metadata
# check the provenance
assert dataset.provenance == ds.data.provenance
# check the qc spec
for qc_spec in dataset.qc_specifications.values():
spec = ds.data.specs[qc_spec.spec_name]
assert spec.description == qc_spec.spec_description
assert spec.qc_spec.driver == dataset.driver
assert spec.qc_spec.method == qc_spec.method
assert spec.qc_spec.basis == qc_spec.basis
assert spec.qc_spec.program == qc_spec.program
# check the keywords
keywords = client.query_keywords(spec.qc_spec.keywords)[0]
assert keywords.values["maxiter"] == dataset.maxiter
assert keywords.values["scf_properties"] == dataset.scf_properties
# query the dataset
ds.query(qc_spec.spec_name)
for index in ds.df.index:
record = ds.df.loc[index].default
assert record.status.value == "COMPLETE"
assert record.error is None
assert len(record.trajectory) > 1
result = record.get_trajectory()[0]
assert "CURRENT DIPOLE X" in result.extras["qcvars"].keys()
assert "SCF QUADRUPOLE XX" in result.extras["qcvars"].keys()
# make sure the PCM result was captured
assert result.extras["qcvars"]["PCM POLARIZATION ENERGY"] < 0
def test_basic_submissions_single_spec(fractal_compute_server, specification):
"""Test submitting a basic dataset to a snowflake server."""
client = FractalClient(fractal_compute_server)
qc_spec, driver = specification
program = qc_spec["program"]
if not has_program(program):
pytest.skip(f"Program '{program}' not found.")
molecules = Molecule.from_file(get_data("butane_conformers.pdb"), "pdb")
factory = BasicDatasetFactory(driver=driver)
factory.add_qc_spec(**qc_spec,
spec_name="default",
spec_description="testing the single points",
overwrite=True)
dataset = factory.create_dataset(
dataset_name=f"Test single points info {program}, {driver}",
molecules=molecules,
description="Test basics dataset",
tagline="Testing single point datasets",
)
with pytest.raises(DatasetInputError):
dataset.submit(client=client, await_result=False)
# now add a mock url so we can submit the data
dataset.metadata.long_description_url = "https://test.org"
# now submit again
dataset.submit(client=client, await_result=False)
fractal_compute_server.await_results()
# make sure of the results are complete
ds = client.get_collection("Dataset", dataset.dataset_name)
# check the metadata
meta = Metadata(**ds.data.metadata)
assert meta == dataset.metadata
assert ds.data.description == dataset.description
assert ds.data.tagline == dataset.dataset_tagline
assert ds.data.tags == dataset.dataset_tags
# check the provenance
assert dataset.provenance == ds.data.provenance
# check the qc spec
assert ds.data.default_driver == dataset.driver
# get the last ran spec
for specification in ds.data.history:
driver, program, method, basis, spec_name = specification
spec = dataset.qc_specifications[spec_name]
assert driver == dataset.driver
assert program == spec.program
assert method == spec.method
assert basis == spec.basis
break
else:
raise RuntimeError(
f"The requested compute was not found in the history {ds.data.history}"
)
for spec in dataset.qc_specifications.values():
query = ds.get_records(
method=spec.method,
basis=spec.basis,
program=spec.program,
)
for index in query.index:
result = query.loc[index].record
assert result.status.value.upper() == "COMPLETE"
assert result.error is None
assert result.return_result is not None
def test_basic_submissions_wavefunction(fractal_compute_server):
"""
Test submitting a basic dataset with a wavefunction protocol and make sure it is executed.
"""
# only a psi4 test
if not has_program("psi4"):
pytest.skip(f"Program psi4 not found.")
client = FractalClient(fractal_compute_server)
molecules = Molecule.from_file(get_data("butane_conformers.pdb"), "pdb")
factory = BasicDatasetFactory(driver="energy")
factory.clear_qcspecs()
factory.add_qc_spec(method="hf",
basis="sto-6g",
program="psi4",
spec_name="default",
spec_description="wavefunction spec",
store_wavefunction="orbitals_and_eigenvalues")
dataset = factory.create_dataset(
dataset_name=f"Test single points with wavefunction",
molecules=molecules,
description="Test basics dataset",
tagline="Testing single point datasets with wavefunction",
)
# now add a mock url so we can submit the data
dataset.metadata.long_description_url = "https://test.org"
# submit the dataset
# now submit again
dataset.submit(client=client, await_result=False)
fractal_compute_server.await_results()
# make sure of the results are complete
ds = client.get_collection("Dataset", dataset.dataset_name)
# check the metadata
meta = Metadata(**ds.data.metadata)
assert meta == dataset.metadata
assert ds.data.description == dataset.description
assert ds.data.tagline == dataset.dataset_tagline
assert ds.data.tags == dataset.dataset_tags
# check the provenance
assert dataset.provenance == ds.data.provenance
# check the qc spec
assert ds.data.default_driver == dataset.driver
# get the last ran spec
for specification in ds.data.history:
driver, program, method, basis, spec_name = specification
spec = dataset.qc_specifications[spec_name]
assert driver == dataset.driver
assert program == spec.program
assert method == spec.method
assert basis == spec.basis
for spec in dataset.qc_specifications.values():
query = ds.get_records(
method=spec.method,
basis=spec.basis,
program=spec.program,
)
for index in query.index:
result = query.loc[index].record
assert result.status.value.upper() == "COMPLETE"
assert result.error is None
assert result.return_result is not None
basis = result.get_wavefunction("basis")
assert basis.name.lower() == "sto-6g"
orbitals = result.get_wavefunction("orbitals_a")
assert orbitals.shape is not None
