def test_print_result(self):
"""Regression test against #198 and general issues with printing results."""
solver = NumPyMinimumEigensolverFactory()
calc = GroundStateEigensolver(self.qubit_converter, solver)
res = calc.solve(self.electronic_structure_problem)
with contextlib.redirect_stdout(io.StringIO()) as out:
print(res)
# do NOT change the below! Lines have been truncated as to not force exact numerical matches
expected = """\
=== GROUND STATE ENERGY ===
* Electronic ground state energy (Hartree): -1.857
- computed part: -1.857
~ Nuclear repulsion energy (Hartree): 0.719
> Total ground state energy (Hartree): -1.137
=== MEASURED OBSERVABLES ===
0: # Particles: 2.000 S: 0.000 S^2: 0.000 M: 0.000
=== DIPOLE MOMENTS ===
~ Nuclear dipole moment (a.u.): [0.0 0.0 1.38
0:
* Electronic dipole moment (a.u.): [0.0 0.0 -1.38
- computed part: [0.0 0.0 -1.38
> Dipole moment (a.u.): [0.0 0.0 0.0] Total: 0.
(debye): [0.0 0.0 0.0] Total: 0.
"""
for truth, expected in zip(out.getvalue().split("\n"),
expected.split("\n")):
assert truth.strip().startswith(expected.strip())
def test_npme(self):
"""Test NumPyMinimumEigensolver"""
solver = NumPyMinimumEigensolverFactory()
calc = GroundStateEigensolver(self.qubit_converter, solver)
res = calc.solve(self.electronic_structure_problem)
self.assertAlmostEqual(res.total_energies[0],
self.reference_energy,
places=6)
def test_total_dipole(self):
"""Regression test against #198.
An issue with calculating the dipole moment that had division None/float.
"""
solver = NumPyMinimumEigensolverFactory()
calc = GroundStateEigensolver(self.qubit_converter, solver)
res = calc.solve(self.electronic_structure_problem)
self.assertAlmostEqual(res.total_dipole_moment_in_debye[0], 0.0, places=1)
def test_numpy_mes(self):
""" Test with NumPyMinimumEigensolver """
solver = NumPyMinimumEigensolverFactory(
use_default_filter_criterion=True)
gsc = GroundStateEigensolver(self.qubit_converter, solver)
esc = QEOM(gsc, 'sd')
results = esc.solve(self.vibrational_problem)
for idx in range(len(self.reference_energies)):
self.assertAlmostEqual(results.computed_vibrational_energies[idx],
self.reference_energies[idx],
places=4)
def test_dict_based_aux_ops(self):
"""Test the `test_dict_based_aux_ops` variant"""
try:
settings.dict_aux_operators = True
solver = NumPyMinimumEigensolverFactory()
calc = GroundStateEigensolver(self.qubit_converter, solver)
res = calc.solve(self.electronic_structure_problem)
self.assertAlmostEqual(res.total_energies[0], self.reference_energy, places=6)
self.assertTrue(
np.all(isinstance(aux_op, dict) for aux_op in res.aux_operator_eigenvalues)
)
self.assertAlmostEqual(
res.aux_operator_eigenvalues[0]["ParticleNumber"][0], 2.0, places=6
)
self.assertAlmostEqual(
res.aux_operator_eigenvalues[0]["ParticleNumber"][1], 0.0, places=6
)
self.assertAlmostEqual(
res.aux_operator_eigenvalues[0]["AngularMomentum"][0], 0.0, places=6
)
self.assertAlmostEqual(
res.aux_operator_eigenvalues[0]["AngularMomentum"][1], 0.0, places=6
)
self.assertAlmostEqual(
res.aux_operator_eigenvalues[0]["Magnetization"][0], 0.0, places=6
)
self.assertAlmostEqual(
res.aux_operator_eigenvalues[0]["Magnetization"][1], 0.0, places=6
)
self.assertAlmostEqual(
res.aux_operator_eigenvalues[0]["DipoleMomentX"][0], 0.0, places=6
)
self.assertAlmostEqual(
res.aux_operator_eigenvalues[0]["DipoleMomentX"][1], 0.0, places=6
)
self.assertAlmostEqual(
res.aux_operator_eigenvalues[0]["DipoleMomentY"][0], 0.0, places=6
)
self.assertAlmostEqual(
res.aux_operator_eigenvalues[0]["DipoleMomentY"][1], 0.0, places=6
)
self.assertAlmostEqual(
res.aux_operator_eigenvalues[0]["DipoleMomentZ"][0], -1.3889487, places=6
)
self.assertAlmostEqual(
res.aux_operator_eigenvalues[0]["DipoleMomentZ"][1], 0.0, places=6
)
finally:
settings.dict_aux_operators = False
def test_aux_ops_reusability(self):
""" Test that the auxiliary operators can be reused """
# Regression test against #1475
solver = NumPyMinimumEigensolverFactory()
calc = GroundStateEigensolver(self.qubit_converter, solver)
modes = 4
h_1 = np.eye(modes, dtype=complex)
h_2 = np.zeros((modes, modes, modes, modes))
aux_ops = [build_ferm_op_from_ints(h_1, h_2)]
aux_ops_copy = copy.deepcopy(aux_ops)
_ = calc.solve(self.electronic_structure_problem)
assert all(frozenset(a.to_list()) == frozenset(b.to_list())
for a, b in zip(aux_ops, aux_ops_copy))
def test_freeze_core_z2_symmetry_compatibility(self):
"""Regression test against #192.
An issue arose when the FreezeCoreTransformer was combined with the automatic Z2Symmetry
reduction. This regression test ensures that this behavior remains fixed.
"""
driver = HDF5Driver(hdf5_input=self.get_resource_path(
"LiH_sto3g.hdf5", "transformers/second_quantization/electronic"))
problem = ElectronicStructureProblem(driver, [FreezeCoreTransformer()])
qubit_converter = QubitConverter(
ParityMapper(),
two_qubit_reduction=True,
z2symmetry_reduction="auto",
)
solver = NumPyMinimumEigensolverFactory()
gsc = GroundStateEigensolver(qubit_converter, solver)
result = gsc.solve(problem)
self.assertAlmostEqual(result.total_energies[0], -7.882, places=2)
def test_aux_ops_reusability(self):
"""Test that the auxiliary operators can be reused"""
# Regression test against #1475
solver = NumPyMinimumEigensolverFactory()
calc = GroundStateEigensolver(self.qubit_converter, solver)
modes = 4
h_1 = np.eye(modes, dtype=complex)
h_2 = np.zeros((modes, modes, modes, modes))
aux_ops = ElectronicEnergy([
OneBodyElectronicIntegrals(ElectronicBasis.MO, (h_1, None)),
TwoBodyElectronicIntegrals(ElectronicBasis.MO,
(h_2, None, None, None)),
], ).second_q_ops()
aux_ops_copy = copy.deepcopy(aux_ops)
_ = calc.solve(self.electronic_structure_problem)
assert all(
frozenset(a.to_list()) == frozenset(b.to_list())
for a, b in zip(aux_ops, aux_ops_copy))
def test_list_based_aux_ops(self):
"""Test the list based aux ops variant"""
msg_ref = (
"List-based `aux_operators` are deprecated as of version 0.3.0 and support "
"for them will be removed no sooner than 3 months after the release. Instead, "
"use dict-based `aux_operators`. You can switch to the dict-based interface "
"immediately, by setting `qiskit_nature.settings.dict_aux_operators` to `True`."
)
with warnings.catch_warnings(record=True) as c_m:
warnings.simplefilter("always")
settings.dict_aux_operators = False
try:
solver = NumPyMinimumEigensolverFactory()
calc = GroundStateEigensolver(self.qubit_converter, solver)
res = calc.solve(self.electronic_structure_problem)
self.assertAlmostEqual(res.total_energies[0],
self.reference_energy,
places=6)
self.assertTrue(
np.all(
isinstance(aux_op, dict)
for aux_op in res.aux_operator_eigenvalues))
aux_op_eigenvalue = res.aux_operator_eigenvalues[0]
self.assertAlmostEqual(aux_op_eigenvalue[0][0], 2.0, places=6)
self.assertAlmostEqual(aux_op_eigenvalue[1][1], 0.0, places=6)
self.assertAlmostEqual(aux_op_eigenvalue[2][0], 0.0, places=6)
self.assertAlmostEqual(aux_op_eigenvalue[2][1], 0.0, places=6)
self.assertAlmostEqual(aux_op_eigenvalue[3][0], 0.0, places=6)
self.assertAlmostEqual(aux_op_eigenvalue[3][1], 0.0, places=6)
self.assertAlmostEqual(aux_op_eigenvalue[4][0], 0.0, places=6)
self.assertAlmostEqual(aux_op_eigenvalue[4][1], 0.0, places=6)
self.assertAlmostEqual(aux_op_eigenvalue[5][0],
-1.3889487,
places=6)
self.assertAlmostEqual(aux_op_eigenvalue[5][1], 0.0, places=6)
finally:
settings.dict_aux_operators = True
msg = str(c_m[0].message)
self.assertEqual(msg, msg_ref)
