def test_h3(self):
"""Test for H3 chain, see also https://github.com/Qiskit/qiskit-aqua/issues/1148."""
atom = "H 0 0 0; H 0 0 1; H 0 0 2"
driver = PySCFDriver(atom=atom, unit=UnitsType.ANGSTROM, charge=0, spin=1, basis="sto3g")
driver_result = driver.run()
electronic_energy = cast(ElectronicEnergy, driver_result.get_property(ElectronicEnergy))
self.assertAlmostEqual(electronic_energy.reference_energy, -1.523996200246108, places=5)
def test_zmatrix(self):
"""Check z-matrix input"""
atom = "H; H 1 1.0"
driver = PySCFDriver(atom=atom, unit=UnitsType.ANGSTROM, charge=0, spin=0, basis="sto3g")
driver_result = driver.run()
electronic_energy = cast(ElectronicEnergy, driver_result.get_property(ElectronicEnergy))
self.assertAlmostEqual(electronic_energy.reference_energy, -1.0661086493179366, places=5)
def test_list_atom(self):
"""Check input with list of strings"""
atom = ["H 0 0 0", "H 0 0 1"]
driver = PySCFDriver(atom=atom, unit=UnitsType.ANGSTROM, charge=0, spin=0, basis="sto3g")
driver_result = driver.run()
electronic_energy = cast(ElectronicEnergy, driver_result.get_property(ElectronicEnergy))
self.assertAlmostEqual(electronic_energy.reference_energy, -1.0661086493179366, places=5)
def test_h4(self):
"""Test for H4 chain"""
atom = "H 0 0 0; H 0 0 1; H 0 0 2; H 0 0 3"
driver = PySCFDriver(atom=atom, unit=UnitsType.ANGSTROM, charge=0, spin=0, basis="sto3g")
driver_result = driver.run()
electronic_energy = cast(ElectronicEnergy, driver_result.get_property(ElectronicEnergy))
self.assertAlmostEqual(electronic_energy.reference_energy, -2.09854593699776, places=5)
def setUp(self):
super().setUp()
self.core_energy = 0.7199
self.num_molecular_orbitals = 2
self.num_electrons = 2
self.spin_number = 0
self.wf_symmetry = 1
self.orb_symmetries = [1, 1]
self.mo_onee = [[1.2563, 0.0], [0.0, 0.4719]]
self.mo_eri = [0.6757, 0.0, 0.1809, 0.6646, 0.0, 0.6986]
try:
driver = PySCFDriver(
atom="H .0 .0 .0; H .0 .0 0.735",
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis="sto3g",
)
driver_result = driver.run()
with tempfile.NamedTemporaryFile() as dump:
FCIDumpDriver.dump(driver_result, dump.name)
# pylint: disable=import-outside-toplevel
from pyscf.tools import fcidump as pyscf_fcidump
self.dumped = pyscf_fcidump.read(dump.name)
except QiskitNatureError:
self.skipTest("PYSCF driver does not appear to be installed.")
except ImportError:
self.skipTest("PYSCF driver does not appear to be installed.")
def setUp(self):
super().setUp()
driver = PySCFDriver(
atom="H .0 .0 .0; H .0 .0 0.735",
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis="sto3g",
)
self.driver_result = driver.run()
def setUp(self):
super().setUp()
algorithm_globals.random_seed = 8
self.driver = PySCFDriver(
atom="H .0 .0 .0; H .0 .0 0.75",
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis="sto3g",
)
self.reference_energies = [
-1.8427016,
-1.8427016 + 0.5943372,
-1.8427016 + 0.95788352,
-1.8427016 + 1.5969296,
]
self.qubit_converter = QubitConverter(JordanWignerMapper())
self.electronic_structure_problem = ElectronicStructureProblem(
self.driver)
solver = NumPyEigensolver()
self.ref = solver
self.quantum_instance = QuantumInstance(
BasicAer.get_backend("statevector_simulator"),
seed_transpiler=90,
seed_simulator=12,
)
def setUp(self):
super().setUp()
self.driver = PySCFDriver(atom="H .0 .0 .0; H .0 .0 0.735",
unit=UnitsType.ANGSTROM,
basis="sto3g")
self.problem = ElectronicStructureProblem(self.driver)
self.expected = -1.85727503
self.qubit_converter = QubitConverter(ParityMapper())
def test_oh_uhf(self):
"""oh uhf test"""
driver = PySCFDriver(
atom=self.o_h,
unit=UnitsType.ANGSTROM,
charge=0,
spin=1,
basis="sto-3g",
method=MethodType.UHF,
)
result = self._run_driver(driver)
self._assert_energy_and_dipole(result, "oh")
def test_lih_uhf(self):
"""lih uhf test"""
driver = PySCFDriver(
atom=self.lih,
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis="sto-3g",
method=MethodType.UHF,
)
result = self._run_driver(driver,
transformers=[FreezeCoreTransformer()])
self._assert_energy_and_dipole(result, "lih")
def test_oh_uhf_parity(self):
"""oh uhf parity test"""
driver = PySCFDriver(
atom=self.o_h,
unit=UnitsType.ANGSTROM,
charge=0,
spin=1,
basis="sto-3g",
method=MethodType.UHF,
)
result = self._run_driver(driver,
converter=QubitConverter(ParityMapper()))
self._assert_energy_and_dipole(result, "oh")
def test_oh_rohf_bk(self):
"""oh rohf bk test"""
driver = PySCFDriver(
atom=self.o_h,
unit=UnitsType.ANGSTROM,
charge=0,
spin=1,
basis="sto-3g",
method=MethodType.ROHF,
)
result = self._run_driver(driver,
converter=QubitConverter(
BravyiKitaevMapper()))
self._assert_energy_and_dipole(result, "oh")
def test_oh_rohf_parity_2q(self):
"""oh rohf parity 2q test"""
driver = PySCFDriver(
atom=self.o_h,
unit=UnitsType.ANGSTROM,
charge=0,
spin=1,
basis="sto-3g",
method=MethodType.ROHF,
)
result = self._run_driver(
driver,
converter=QubitConverter(ParityMapper(), two_qubit_reduction=True))
self._assert_energy_and_dipole(result, "oh")
def test_lih_rhf_parity_2q(self):
"""lih rhf parity 2q test"""
driver = PySCFDriver(
atom=self.lih,
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis="sto-3g",
method=MethodType.RHF,
)
result = self._run_driver(
driver,
converter=QubitConverter(ParityMapper(), two_qubit_reduction=True),
transformers=[FreezeCoreTransformer()],
)
self._assert_energy_and_dipole(result, "lih")
def test_lih_rhf_bk(self):
"""lih rhf bk test"""
driver = PySCFDriver(
atom=self.lih,
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis="sto-3g",
method=MethodType.RHF,
)
result = self._run_driver(
driver,
converter=QubitConverter(BravyiKitaevMapper()),
transformers=[FreezeCoreTransformer()],
)
self._assert_energy_and_dipole(result, "lih")
def setUp(self):
super().setUp()
self.driver = PySCFDriver(atom="H 0 0 0.735; H 0 0 0", basis="631g")
self.qubit_converter = QubitConverter(ParityMapper(),
two_qubit_reduction=True)
self.electronic_structure_problem = ElectronicStructureProblem(
self.driver, [FreezeCoreTransformer()])
self.num_spin_orbitals = 8
self.num_particles = (1, 1)
# because we create the initial state and ansatzes early, we need to ensure the qubit
# converter already ran such that convert_match works as expected
_ = self.qubit_converter.convert(
self.electronic_structure_problem.second_q_ops()[
self.electronic_structure_problem.main_property_name],
self.num_particles,
)
self.reference_energy_pUCCD = -1.1434447924298028
self.reference_energy_UCCD0 = -1.1476045878481704
self.reference_energy_UCCD0full = -1.1515491334334347
# reference energy of UCCSD/VQE with tapering everywhere
self.reference_energy_UCCSD = -1.1516142309717594
# reference energy of UCCSD/VQE when no tapering on excitations is used
self.reference_energy_UCCSD_no_tap_exc = -1.1516142309717594
# excitations for succ
self.reference_singlet_double_excitations = [
[0, 1, 4, 5],
[0, 1, 4, 6],
[0, 1, 4, 7],
[0, 2, 4, 6],
[0, 2, 4, 7],
[0, 3, 4, 7],
]
# groups for succ_full
self.reference_singlet_groups = [
[[0, 1, 4, 5]],
[[0, 1, 4, 6], [0, 2, 4, 5]],
[[0, 1, 4, 7], [0, 3, 4, 5]],
[[0, 2, 4, 6]],
[[0, 2, 4, 7], [0, 3, 4, 6]],
[[0, 3, 4, 7]],
]
def setUp(self):
super().setUp()
# pylint: disable=import-outside-toplevel
from qiskit_nature.drivers.second_quantization import PySCFDriver
PySCFDriver(atom="Li .0 .0 .0; H .0 .0 1.6")
try:
# pylint: disable=import-outside-toplevel
# pylint: disable=unused-import
from qiskit import Aer
_ = Aer.get_backend("aer_simulator_statevector")
except ImportError as ex: # pylint: disable=broad-except
self.skipTest(
f"Aer doesn't appear to be installed. Error: '{str(ex)}'")
return
def test_sector_locator_h2o(self):
"""Test sector locator."""
driver = PySCFDriver(
atom=
"O 0.0000 0.0000 0.1173; H 0.0000 0.07572 -0.4692;H 0.0000 -0.07572 -0.4692",
basis="sto-3g",
)
es_problem = ElectronicStructureProblem(driver)
qubit_conv = QubitConverter(mapper=ParityMapper(),
two_qubit_reduction=True,
z2symmetry_reduction="auto")
qubit_conv.convert(
es_problem.second_q_ops()[0],
num_particles=es_problem.num_particles,
sector_locator=es_problem.symmetry_sector_locator,
)
self.assertListEqual(qubit_conv.z2symmetries.tapering_values, [1, -1])
def test_LiH(self):
"""Lih test"""
driver = PySCFDriver(
atom="Li .0 .0 .0; H .0 .0 1.6",
unit=UnitsType.ANGSTROM,
basis="sto3g",
)
transformer = ActiveSpaceTransformer(num_electrons=2,
num_molecular_orbitals=3)
problem = ElectronicStructureProblem(driver, [transformer])
solver = VQEUCCFactory(quantum_instance=QuantumInstance(
BasicAer.get_backend("statevector_simulator")))
calc = AdaptVQE(self.qubit_converter, solver)
res = calc.solve(problem)
self.assertAlmostEqual(res.electronic_energies[0],
-8.855126478,
places=6)
def setUp(self):
super().setUp()
algorithm_globals.random_seed = 8
self.driver = PySCFDriver(
atom="H .0 .0 .0; H .0 .0 0.75",
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis="sto3g",
)
self.qubit_converter = QubitConverter(JordanWignerMapper())
self.electronic_structure_problem = ElectronicStructureProblem(
self.driver)
self.electronic_structure_problem.second_q_ops()
self.particle_number = (
self.electronic_structure_problem.grouped_property_transformed.
get_property("ParticleNumber"))
def setUp(self):
super().setUp()
self.driver = PySCFDriver(
atom="H .0 .0 .0; H .0 .0 0.75",
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis="sto3g",
)
self.electronic_structure_problem = ElectronicStructureProblem(
self.driver)
# pylint: disable=unused-argument
def filter_criterion(eigenstate, eigenvalue, aux_values):
return np.isclose(aux_values[0][0], 2.0)
self.k = 99
self._numpy_eigensolver_factory = NumPyEigensolverFactory(
filter_criterion=filter_criterion, k=self.k)
def setUp(self):
super().setUp()
PySCFDriver(atom=self.lih)
def test_invalid_atom_type(self):
"""Atom is string with ; separator or list of string"""
with self.assertRaises(QiskitNatureError):
PySCFDriver(atom=("H", 0, 0, 0))
def test_readme_sample(self):
"""readme sample test"""
# pylint: disable=import-outside-toplevel,redefined-builtin
def print(*args):
"""overloads print to log values"""
if args:
self.log.debug(args[0], *args[1:])
# --- Exact copy of sample code ----------------------------------------
from qiskit_nature.drivers import UnitsType
from qiskit_nature.drivers.second_quantization import PySCFDriver
from qiskit_nature.problems.second_quantization.electronic import ElectronicStructureProblem
# Use PySCF, a classical computational chemistry software
# package, to compute the one-body and two-body integrals in
# electronic-orbital basis, necessary to form the Fermionic operator
driver = PySCFDriver(atom="H .0 .0 .0; H .0 .0 0.735",
unit=UnitsType.ANGSTROM,
basis="sto3g")
problem = ElectronicStructureProblem(driver)
# generate the second-quantized operators
second_q_ops = problem.second_q_ops()
main_op = second_q_ops[0]
particle_number = problem.grouped_property_transformed.get_property(
"ParticleNumber")
num_particles = (particle_number.num_alpha, particle_number.num_beta)
num_spin_orbitals = particle_number.num_spin_orbitals
# setup the classical optimizer for VQE
from qiskit.algorithms.optimizers import L_BFGS_B
optimizer = L_BFGS_B()
# setup the mapper and qubit converter
from qiskit_nature.mappers.second_quantization import ParityMapper
from qiskit_nature.converters.second_quantization import QubitConverter
mapper = ParityMapper()
converter = QubitConverter(mapper=mapper, two_qubit_reduction=True)
# map to qubit operators
qubit_op = converter.convert(main_op, num_particles=num_particles)
# setup the initial state for the ansatz
from qiskit_nature.circuit.library import HartreeFock
init_state = HartreeFock(num_spin_orbitals, num_particles, converter)
# setup the ansatz for VQE
from qiskit.circuit.library import TwoLocal
ansatz = TwoLocal(num_spin_orbitals, ["ry", "rz"], "cz")
# add the initial state
ansatz.compose(init_state, front=True, inplace=True)
# set the backend for the quantum computation
from qiskit import Aer
backend = Aer.get_backend("aer_simulator_statevector")
# setup and run VQE
from qiskit.algorithms import VQE
algorithm = VQE(ansatz, optimizer=optimizer, quantum_instance=backend)
result = algorithm.compute_minimum_eigenvalue(qubit_op)
print(result.eigenvalue.real)
electronic_structure_result = problem.interpret(result)
print(electronic_structure_result)
# ----------------------------------------------------------------------
self.assertAlmostEqual(result.eigenvalue.real,
-1.8572750301938803,
places=6)
