6050403917

Committed 01 Sep 2023 02:04PM UTC coverage: 85.873% (-0.01%) from 85.887%

Build # 6050403917

Build Type

push

github

Committed by

web-flow

Commit Message

Rotate poBranch deploy key (backport #1230) (#1232)

* Rotate poBranch deploy key (#1230)

This commit rotates the poBranch deploy key used for pushing translation
files to the qiskit-translations repository. The old key being used was
no longer valid so it needs to be updated to the new one.

(cherry picked from commit 79e6290ea)

* Update constraints.txt

---------

Co-authored-by: Matthew Treinish <mtreinish@kortar.org>
Co-authored-by: Steve Wood <40241007+woodsp-ibm@users.noreply.github.com>

Run Details

18588 of 21646 relevant lines covered (85.87%)

0.86 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

84.43

/qiskit_nature/drivers/second_quantization/psi4d/psi4driver.py

# This code is part of Qiskit.
#
# (C) Copyright IBM 2018, 2022.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.

""" PSI4 Driver """

from __future__ import annotations

import logging
import os
import subprocess
import sys
import tempfile
from pathlib import Path
from typing import Any, Optional, Union, cast

from qiskit_nature import QiskitNatureError
from qiskit_nature.hdf5 import load_from_hdf5
from qiskit_nature.properties.second_quantization.electronic import (
    AngularMomentum,
    ElectronicStructureDriverResult,
    Magnetization,
)
import qiskit_nature.optionals as _optionals

from ..electronic_structure_driver import ElectronicStructureDriver, MethodType
from ...molecule import Molecule
from ...units_type import UnitsType
from ....exceptions import UnsupportMethodError

logger = logging.getLogger(__name__)


@_optionals.HAS_PSI4.require_in_instance
class PSI4Driver(ElectronicStructureDriver):
    """
    Qiskit Nature driver using the PSI4 program.

    See http://www.psicode.org/
    """

    def __init__(
        self,
        config: Union[
            str, list[str]
        ] = "molecule h2 {\n  0 1\n  H  0.0 0.0 0.0\n  H  0.0 0.0 0.735\n}\n\n"
        "set {\n  basis sto-3g\n  scf_type pk\n  reference rhf\n",
    ) -> None:
        """
        Args:
            config: A molecular configuration conforming to PSI4 format.

        Raises:
            QiskitNatureError: Invalid Input
        """
        super().__init__()
        if not isinstance(config, str) and not isinstance(config, list):
            raise QiskitNatureError(f"Invalid config for PSI4 Driver '{config}'")

        if isinstance(config, list):
            config = "\n".join(config)

        self._config = config

    @staticmethod
    @_optionals.HAS_PSI4.require_in_call
    def from_molecule(
        molecule: Molecule,
        basis: str = "sto3g",
        method: MethodType = MethodType.RHF,
        driver_kwargs: Optional[dict[str, Any]] = None,
    ) -> "PSI4Driver":
        """
        Args:
            molecule: molecule
            basis: basis set
            method: Hartree-Fock Method type
            driver_kwargs: kwargs to be passed to driver
        Returns:
            driver

        Raises:
            QiskitNatureError: Unknown unit
        """
        # Ignore kwargs parameter for this driver
        del driver_kwargs
        PSI4Driver.check_method_supported(method)
        basis = PSI4Driver.to_driver_basis(basis)

        if molecule.units == UnitsType.ANGSTROM:
            units = "ang"
        elif molecule.units == UnitsType.BOHR:
            units = "bohr"
        else:
            raise QiskitNatureError(f"Unknown unit '{molecule.units.value}'")
        name = "".join([name for (name, _) in molecule.geometry])
        geom = "\n".join(
            [name + " " + " ".join(map(str, coord)) for (name, coord) in molecule.geometry]
        )
        cfg1 = f"molecule {name} {{\nunits {units}\n"
        cfg2 = f"{molecule.charge} {molecule.multiplicity}\n"
        cfg3 = f"{geom}\nno_com\nno_reorient\n}}\n\n"
        cfg4 = f"set {{\n basis {basis}\n scf_type pk\n reference {method.value}\n}}"
        return PSI4Driver(cfg1 + cfg2 + cfg3 + cfg4)

    @staticmethod
    def to_driver_basis(basis: str) -> str:
        """
        Converts basis to a driver acceptable basis
        Args:
            basis: The basis set to be used
        Returns:
            driver acceptable basis
        """
        if basis == "sto3g":
            return "sto-3g"
        return basis

    @staticmethod
    def check_method_supported(method: MethodType) -> None:
        """
        Checks that PSI4 supports this method.
        Args:
            method: Method type

        Raises:
            UnsupportMethodError: If method not supported.
        """
        if method not in [MethodType.RHF, MethodType.ROHF, MethodType.UHF]:
            raise UnsupportMethodError(f"Invalid PSI4 method {method.value}.")

    def run(self) -> ElectronicStructureDriverResult:
        cfg = self._config

        psi4d_directory = Path(__file__).resolve().parent
        template_file = psi4d_directory.joinpath("_template.txt")
        qiskit_nature_directory = psi4d_directory.parent.parent

        input_text = [cfg]
        input_text += ["import sys"]
        syspath = (
            "['"
            + qiskit_nature_directory.as_posix()
            + "','"
            + "','".join(Path(p).as_posix() for p in sys.path)
            + "']"
        )

        input_text += ["sys.path = " + syspath + " + sys.path"]

        with open(template_file, "r", encoding="utf8") as file:
            input_text += [line.strip("\n") for line in file.readlines()]

        file_fd, hdf5_file = tempfile.mkstemp(suffix=".hdf5")
        os.close(file_fd)

        input_text += [
            f'save_to_hdf5(_q_driver_result, "{Path(hdf5_file).as_posix()}", replace=True)'
        ]

        file_fd, input_file = tempfile.mkstemp(suffix=".inp")
        os.close(file_fd)
        with open(input_file, "w", encoding="utf8") as stream:
            stream.write("\n".join(input_text))

        file_fd, output_file = tempfile.mkstemp(suffix=".out")
        os.close(file_fd)
        try:
            PSI4Driver._run_psi4(input_file, output_file)
            if logger.isEnabledFor(logging.DEBUG):
                with open(output_file, "r", encoding="utf8") as file:
                    logger.debug("PSI4 output file:\n%s", file.read())
        finally:
            run_directory = os.getcwd()
            for local_file in os.listdir(run_directory):
                if local_file.endswith(".clean"):
                    os.remove(run_directory + "/" + local_file)
            try:
                os.remove("timer.dat")
            except Exception:  # pylint: disable=broad-except
                pass

            try:
                os.remove(input_file)
            except Exception:  # pylint: disable=broad-except
                pass

            try:
                os.remove(output_file)
            except Exception:  # pylint: disable=broad-except
                pass

        driver_result = cast(ElectronicStructureDriverResult, load_from_hdf5(hdf5_file))

        try:
            os.remove(hdf5_file)
        except Exception:  # pylint: disable=broad-except
            pass

        # TODO: once https://github.com/Qiskit/qiskit-nature/issues/312 is fixed we can stop adding
        # these properties by default.
        # if not settings.dict_aux_operators:
        num_spin_orbitals = driver_result.get_property("ParticleNumber").num_spin_orbitals
        driver_result.add_property(AngularMomentum(num_spin_orbitals))
        driver_result.add_property(Magnetization(num_spin_orbitals))

        # inject Psi4 config (because it is not available at runtime inside the template)
        driver_metadata = driver_result.get_property("DriverMetadata")
        driver_metadata.config = cfg

        return driver_result

    @staticmethod
    def _run_psi4(input_file, output_file):

        # Run psi4.
        process = None
        try:
            with subprocess.Popen(
                [_optionals.PSI4, input_file, output_file],
                stdout=subprocess.PIPE,
                universal_newlines=True,
            ) as process:
                stdout, _ = process.communicate()
                process.wait()
        except Exception as ex:
            if process is not None:
                process.kill()

            raise QiskitNatureError(f"{_optionals.PSI4} run has failed") from ex

        if process.returncode != 0:
            errmsg = ""
            if stdout is not None:
                lines = stdout.splitlines()
                for line in lines:
                    logger.error(line)
                    errmsg += line + "\n"
            raise QiskitNatureError(
                f"{_optionals.PSI4} process return code {process.returncode}\n{errmsg}"
            )

1	# This code is part of Qiskit.
2	#
3	# (C) Copyright IBM 2018, 2022.
4	#
5	# This code is licensed under the Apache License, Version 2.0. You may
6	# obtain a copy of this license in the LICENSE.txt file in the root directory
7	# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
8	#
9	# Any modifications or derivative works of this code must retain this
10	# copyright notice, and modified files need to carry a notice indicating
11	# that they have been altered from the originals.
12
13	""" PSI4 Driver """	1✔
14
15	from __future__ import annotations	1✔
16
17	import logging	1✔
18	import os	1✔
19	import subprocess	1✔
20	import sys	1✔
21	import tempfile	1✔
22	from pathlib import Path	1✔
23	from typing import Any, Optional, Union, cast	1✔
24
25	from qiskit_nature import QiskitNatureError	1✔
26	from qiskit_nature.hdf5 import load_from_hdf5	1✔
27	from qiskit_nature.properties.second_quantization.electronic import (	1✔
28	AngularMomentum,
29	ElectronicStructureDriverResult,
30	Magnetization,
31	)
32	import qiskit_nature.optionals as _optionals	1✔
33
34	from ..electronic_structure_driver import ElectronicStructureDriver, MethodType	1✔
35	from ...molecule import Molecule	1✔
36	from ...units_type import UnitsType	1✔
37	from ....exceptions import UnsupportMethodError	1✔
38
39	logger = logging.getLogger(__name__)	1✔
40
41
42	@_optionals.HAS_PSI4.require_in_instance	1✔
43	class PSI4Driver(ElectronicStructureDriver):	1✔
44	"""
45	Qiskit Nature driver using the PSI4 program.
46
47	See http://www.psicode.org/
48	"""
49
50	def __init__(	1✔
51	self,
52	config: Union[
53	str, list[str]
54	] = "molecule h2 {\n 0 1\n H 0.0 0.0 0.0\n H 0.0 0.0 0.735\n}\n\n"
55	"set {\n basis sto-3g\n scf_type pk\n reference rhf\n",
56	) -> None:
57	"""
58	Args:
59	config: A molecular configuration conforming to PSI4 format.
60
61	Raises:
62	QiskitNatureError: Invalid Input
63	"""
64	super().__init__()	1✔
65	if not isinstance(config, str) and not isinstance(config, list):	1✔
66	raise QiskitNatureError(f"Invalid config for PSI4 Driver '{config}'")	1✔
67
68	if isinstance(config, list):	1✔
69	config = "\n".join(config)	1✔
70
71	self._config = config	1✔
72
73	@staticmethod	1✔
74	@_optionals.HAS_PSI4.require_in_call	1✔
75	def from_molecule(	1✔
76	molecule: Molecule,
77	basis: str = "sto3g",
78	method: MethodType = MethodType.RHF,
79	driver_kwargs: Optional[dict[str, Any]] = None,
80	) -> "PSI4Driver":
81	"""
82	Args:
83	molecule: molecule
84	basis: basis set
85	method: Hartree-Fock Method type
86	driver_kwargs: kwargs to be passed to driver
87	Returns:
88	driver
89
90	Raises:
91	QiskitNatureError: Unknown unit
92	"""
93	# Ignore kwargs parameter for this driver
94	del driver_kwargs	1✔
95	PSI4Driver.check_method_supported(method)	1✔
96	basis = PSI4Driver.to_driver_basis(basis)	1✔
97
98	if molecule.units == UnitsType.ANGSTROM:	1✔
99	units = "ang"	1✔
100	elif molecule.units == UnitsType.BOHR:	×
101	units = "bohr"	×
102	else:
103	raise QiskitNatureError(f"Unknown unit '{molecule.units.value}'")	×
104	name = "".join([name for (name, _) in molecule.geometry])	1✔
105	geom = "\n".join(	1✔
106	[name + " " + " ".join(map(str, coord)) for (name, coord) in molecule.geometry]
107	)
108	cfg1 = f"molecule {name} {{\nunits {units}\n"	1✔
109	cfg2 = f"{molecule.charge} {molecule.multiplicity}\n"	1✔
110	cfg3 = f"{geom}\nno_com\nno_reorient\n}}\n\n"	1✔
111	cfg4 = f"set {{\n basis {basis}\n scf_type pk\n reference {method.value}\n}}"	1✔
112	return PSI4Driver(cfg1 + cfg2 + cfg3 + cfg4)	1✔
113
114	@staticmethod	1✔
115	def to_driver_basis(basis: str) -> str:
116	"""
117	Converts basis to a driver acceptable basis
118	Args:
119	basis: The basis set to be used
120	Returns:
121	driver acceptable basis
122	"""
123	if basis == "sto3g":	1✔
124	return "sto-3g"	1✔
125	return basis	×
126
127	@staticmethod	1✔
128	def check_method_supported(method: MethodType) -> None:
129	"""
130	Checks that PSI4 supports this method.
131	Args:
132	method: Method type
133
134	Raises:
135	UnsupportMethodError: If method not supported.
136	"""
137	if method not in [MethodType.RHF, MethodType.ROHF, MethodType.UHF]:	1✔
138	raise UnsupportMethodError(f"Invalid PSI4 method {method.value}.")	1✔
139
140	def run(self) -> ElectronicStructureDriverResult:	1✔
141	cfg = self._config	1✔
142
143	psi4d_directory = Path(__file__).resolve().parent	1✔
144	template_file = psi4d_directory.joinpath("_template.txt")	1✔
145	qiskit_nature_directory = psi4d_directory.parent.parent	1✔
146
147	input_text = [cfg]	1✔
148	input_text += ["import sys"]	1✔
149	syspath = (	1✔
150	"['"
151	+ qiskit_nature_directory.as_posix()
152	+ "','"
153	+ "','".join(Path(p).as_posix() for p in sys.path)
154	+ "']"
155	)
156
157	input_text += ["sys.path = " + syspath + " + sys.path"]	1✔
158
159	with open(template_file, "r", encoding="utf8") as file:	1✔
160	input_text += [line.strip("\n") for line in file.readlines()]	1✔
161
162	file_fd, hdf5_file = tempfile.mkstemp(suffix=".hdf5")	1✔
163	os.close(file_fd)	1✔
164
165	input_text += [	1✔
166	f'save_to_hdf5(_q_driver_result, "{Path(hdf5_file).as_posix()}", replace=True)'
167	]
168
169	file_fd, input_file = tempfile.mkstemp(suffix=".inp")	1✔
170	os.close(file_fd)	1✔
171	with open(input_file, "w", encoding="utf8") as stream:	1✔
172	stream.write("\n".join(input_text))	1✔
173
174	file_fd, output_file = tempfile.mkstemp(suffix=".out")	1✔
175	os.close(file_fd)	1✔
176	try:	1✔
177	PSI4Driver._run_psi4(input_file, output_file)	1✔
178	if logger.isEnabledFor(logging.DEBUG):	1✔
179	with open(output_file, "r", encoding="utf8") as file:	×
180	logger.debug("PSI4 output file:\n%s", file.read())	×
181	finally:
182	run_directory = os.getcwd()	1✔
183	for local_file in os.listdir(run_directory):	1✔
184	if local_file.endswith(".clean"):	1✔
185	os.remove(run_directory + "/" + local_file)	×
186	try:	1✔
187	os.remove("timer.dat")	1✔
188	except Exception: # pylint: disable=broad-except	×
189	pass	×
190
191	try:	1✔
192	os.remove(input_file)	1✔
193	except Exception: # pylint: disable=broad-except	×
194	pass	×
195
196	try:	1✔
197	os.remove(output_file)	1✔
198	except Exception: # pylint: disable=broad-except	×
199	pass	×
200
201	driver_result = cast(ElectronicStructureDriverResult, load_from_hdf5(hdf5_file))	1✔
202
203	try:	1✔
204	os.remove(hdf5_file)	1✔
205	except Exception: # pylint: disable=broad-except	×
206	pass	×
207
208	# TODO: once https://github.com/Qiskit/qiskit-nature/issues/312 is fixed we can stop adding
209	# these properties by default.
210	# if not settings.dict_aux_operators:
211	num_spin_orbitals = driver_result.get_property("ParticleNumber").num_spin_orbitals	1✔
212	driver_result.add_property(AngularMomentum(num_spin_orbitals))	1✔
213	driver_result.add_property(Magnetization(num_spin_orbitals))	1✔
214
215	# inject Psi4 config (because it is not available at runtime inside the template)
216	driver_metadata = driver_result.get_property("DriverMetadata")	1✔
217	driver_metadata.config = cfg	1✔
218
219	return driver_result	1✔
220
221	@staticmethod	1✔
222	def _run_psi4(input_file, output_file):
223
224	# Run psi4.
225	process = None	1✔
226	try:	1✔
227	with subprocess.Popen(	1✔
228	[_optionals.PSI4, input_file, output_file],
229	stdout=subprocess.PIPE,
230	universal_newlines=True,
231	) as process:
232	stdout, _ = process.communicate()	1✔
233	process.wait()	1✔
234	except Exception as ex:	×
235	if process is not None:	×
236	process.kill()	×
237
238	raise QiskitNatureError(f"{_optionals.PSI4} run has failed") from ex	×
239
240	if process.returncode != 0:	1✔
241	errmsg = ""	1✔
242	if stdout is not None:	1✔
243	lines = stdout.splitlines()	1✔
244	for line in lines:	1✔
245	logger.error(line)	1✔
246	errmsg += line + "\n"	1✔
247	raise QiskitNatureError(	1✔
248	f"{_optionals.PSI4} process return code {process.returncode}\n{errmsg}"
249	)

qiskit-community / qiskit-nature / 6050403917

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous