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)