Modular Driver Result

.pylintdict

@@ -72,6 +72,7 @@ dataset
 dcx
 debye
 deepcopy
+dft
 diag
 diagonalizes
 diagonalizing
@@ -93,6 +94,7 @@ eigenstate
 eigenstateresult
 eigenstates
 einact
+einsum
 endian
 endif
 enum
@@ -197,6 +199,7 @@ mcrz
 mct
 mcu
 mcx
+metadata
 microsoft
 minao
 mixin
@@ -323,8 +326,10 @@ str
 subcircuits
 subclasses
 submodules
+subtype
 succ
 sudo
+superpositions
 sx
 sxdg
 symm
@@ -375,6 +380,7 @@ watson
 wavefunction
 whitespace
 wigner
+xcf
 xcfun
 xdata
 xy

README.md

@@ -74,10 +74,10 @@ problem = ElectronicStructureProblem(driver)
 second_q_ops = problem.second_q_ops()
 main_op = second_q_ops[0]
 
-num_particles = (problem.molecule_data_transformed.num_alpha,
-                 problem.molecule_data_transformed.num_beta)
+particle_number = problem.properties_transformed.get_property("ParticleNumber")
 
-num_spin_orbitals = 2 * problem.molecule_data.num_molecular_orbitals
+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

constraints.txt

@@ -1,4 +1,4 @@
-astroid==2.5.6
-pylint==2.8.3
+astroid==2.6.1
+pylint==2.9.0
 numpy>=1.20.0 ; python_version>'3.6'
 

qiskit_nature/algorithms/ground_state_solvers/minimum_eigensolver_factories/vqe_ucc_factory.py

@@ -23,11 +23,13 @@
 from qiskit.utils import QuantumInstance
 
 from qiskit_nature.circuit.library import HartreeFock, UCC, UCCSD
-from qiskit_nature.drivers.second_quantization import QMolecule
 from qiskit_nature.converters.second_quantization import QubitConverter
 from qiskit_nature.problems.second_quantization.electronic import (
     ElectronicStructureProblem,
 )
+from qiskit_nature.properties.second_quantization.electronic import (
+    ParticleNumber,
+)
 from .minimum_eigensolver_factory import MinimumEigensolverFactory
 
 
@@ -188,13 +190,10 @@ def get_solver(  # type: ignore[override]
             A VQE suitable to compute the ground state of the molecule transformed
             by ``transformation``.
         """
-        q_molecule_transformed = cast(QMolecule, problem.molecule_data_transformed)
-        num_molecular_orbitals = q_molecule_transformed.num_molecular_orbitals
-        num_particles = (
-            q_molecule_transformed.num_alpha,
-            q_molecule_transformed.num_beta,
-        )
-        num_spin_orbitals = 2 * num_molecular_orbitals
+        driver_result = problem.properties_transformed
+        particle_number = cast(ParticleNumber, driver_result.get_property(ParticleNumber))
+        num_spin_orbitals = particle_number.num_spin_orbitals
+        num_particles = particle_number.num_alpha, particle_number.num_beta
 
         initial_state = self.initial_state
         if initial_state is None:

qiskit_nature/algorithms/ground_state_solvers/minimum_eigensolver_factories/vqe_uvcc_factory.py

@@ -22,11 +22,13 @@
 from qiskit.opflow.gradients import GradientBase
 from qiskit.utils import QuantumInstance
 from qiskit_nature.circuit.library import UVCC, UVCCSD, VSCF
-from qiskit_nature.drivers.second_quantization import WatsonHamiltonian
 from qiskit_nature.converters.second_quantization import QubitConverter
 from qiskit_nature.problems.second_quantization.vibrational import (
     VibrationalStructureProblem,
 )
+from qiskit_nature.properties.second_quantization.vibrational import (
+    VibrationalStructureDriverResult,
+)
 
 from .minimum_eigensolver_factory import MinimumEigensolverFactory
 
@@ -189,9 +191,9 @@ def get_solver(  # type: ignore[override]
             by ``transformation``.
         """
 
-        watson_hamiltonian_transformed = cast(WatsonHamiltonian, problem.molecule_data_transformed)
-        num_modals = problem.num_modals
-        num_modes = watson_hamiltonian_transformed.num_modes
+        basis = cast(VibrationalStructureDriverResult, problem.properties_transformed).basis
+        num_modals = basis.num_modals_per_mode
+        num_modes = len(num_modals)
 
         if isinstance(num_modals, int):
             num_modals = [num_modals] * num_modes

qiskit_nature/constants.py

@@ -36,3 +36,5 @@
 HBAR_J_S = 1.054571800e-34  # note this is h/2Pi
 H_J_S = 6.62607015e-34
 KB_J_PER_K = 1.3806488e-23
+BOHR = 0.52917721092  # No of Angstroms in Bohr (from 2010 CODATA)
+DEBYE = 0.393430307  # No ea0 in Debye. Use to convert our dipole moment numbers to Debye

qiskit_nature/drivers/molecule.py

@@ -345,6 +345,11 @@ def units(self):
         """The geometry coordinate units"""
         return UnitsType.ANGSTROM
 
+    @property
+    def atoms(self) -> List[str]:
+        """Get the list of atoms"""
+        return [atom for atom, _ in self._geometry]
+
     @property
     def geometry(self) -> List[Tuple[str, List[float]]]:
         """Get geometry accounting for any perturbations"""

qiskit_nature/problems/second_quantization/base_problem.py

@@ -19,29 +19,53 @@
 
 from qiskit.opflow import PauliSumOp, Z2Symmetries
 
+from qiskit_nature import QiskitNatureError
 from qiskit_nature.drivers.second_quantization import BaseDriver, QMolecule, WatsonHamiltonian
 from qiskit_nature.converters.second_quantization import QubitConverter
+from qiskit_nature.properties.second_quantization import GroupedSecondQuantizedProperty
 from qiskit_nature.results import EigenstateResult
+from qiskit_nature.transformers import BaseTransformer as LegacyBaseTransformer
 from qiskit_nature.transformers.second_quantization import BaseTransformer
 
 
 class BaseProblem(ABC):
     """Base Problem"""
 
-    def __init__(self, driver: BaseDriver, transformers: Optional[List[BaseTransformer]] = None):
+    def __init__(
+        self,
+        driver: BaseDriver,
+        transformers: Optional[List[Union[LegacyBaseTransformer, BaseTransformer]]] = None,
+    ):
         """
 
         Args:
             driver: A driver encoding the molecule information.
             transformers: A list of transformations to be applied to the molecule.
+
+        Raises:
+            QiskitNatureError: if new and legacy transformer instances are mixed.
         """
 
         self.driver = driver
         self.transformers = transformers or []
 
+        self._legacy_transform = False
+        new_transformers = False
+        for trafo in self.transformers:
+            if isinstance(trafo, LegacyBaseTransformer):
+                self._legacy_transform = True
+            elif isinstance(trafo, BaseTransformer):
+                new_transformers = True
+        if self._legacy_transform and new_transformers:
+            raise QiskitNatureError(
+                "A mix of current and deprecated transformers is not supported!"
+            )
+
         self._molecule_data: Union[QMolecule, WatsonHamiltonian] = None
         self._molecule_data_transformed: Union[QMolecule, WatsonHamiltonian] = None
 
+        self._properties_transformed: GroupedSecondQuantizedProperty = None
+
     @property
     def molecule_data(self) -> Union[QMolecule, WatsonHamiltonian]:
         """Returns the raw molecule data object."""
@@ -52,6 +76,11 @@ def molecule_data_transformed(self) -> Union[QMolecule, WatsonHamiltonian]:
         """Returns the raw transformed molecule data object."""
         return self._molecule_data_transformed
 
+    @property
+    def properties_transformed(self) -> GroupedSecondQuantizedProperty:
+        """Returns the transformed GroupedSecondQuantizedProperty object."""
+        return self._properties_transformed
+
     @property
     def num_particles(self) -> Optional[Tuple[int, int]]:
         """Returns the number of particles, if available."""

qiskit_nature/problems/second_quantization/electronic/builders/fermionic_op_builder.py

@@ -0,0 +1,72 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# 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.
+
+""" Fermionic operator builder. """
+
+from typing import List
+
+import numpy as np
+
+from qiskit_nature.deprecation import DeprecatedType, deprecate_function
+from qiskit_nature.operators.second_quantization import FermionicOp
+from qiskit_nature.properties.second_quantization.electronic.bases import ElectronicBasis
+from qiskit_nature.properties.second_quantization.electronic.integrals import (
+    ElectronicIntegrals,
+    IntegralProperty,
+    OneBodyElectronicIntegrals,
+    TwoBodyElectronicIntegrals,
+)
+
+
+@deprecate_function(
+    "0.2.0",
+    DeprecatedType.CLASS,
+    "IntegralProperty",
+    "from qiskit_nature.properties.second_quantization.electronic.integrals in combination with the"
+    " more versatile ElectronicIntegrals containers",
+)
+def build_ferm_op_from_ints(
+    one_body_integrals: np.ndarray, two_body_integrals: np.ndarray = None
+) -> FermionicOp:
+    """**DEPRECATED!**
+    Builds a fermionic operator based on 1- and/or 2-body integrals. Integral values are used for
+    the coefficients of the second-quantized Hamiltonian that is built. If integrals are stored
+    in the '*chemist*' notation
+             h2(i,j,k,l) --> adag_i adag_k a_l a_j
+    they are required to be in block spin format and also have indices reordered as follows
+    'ijkl->ljik'.
+    There is another popular notation, the '*physicist*' notation
+             h2(i,j,k,l) --> adag_i adag_j a_k a_l
+    If you are using the '*physicist*' notation, you need to convert it to
+    the '*chemist*' notation. E.g. h2=numpy.einsum('ikmj->ijkm', h2)
+    The :class:`~qiskit_nature.drivers.second_quantization.QMolecule` class has
+    :attr:`~qiskit_nature.drivers.second_quantization.QMolecule.one_body_integrals` and
+    :attr:`~qiskit_nature.drivers.second_quantization.QMolecule.two_body_integrals` properties that
+    can be directly supplied to the `h1` and `h2` parameters here respectively.
+
+    Args:
+        one_body_integrals (numpy.ndarray): One-body integrals stored in the chemist notation.
+        two_body_integrals (numpy.ndarray): Two-body integrals stored in the chemist notation.
+
+    Returns:
+        FermionicOp: FermionicOp built from 1- and/or 2-body integrals.
+    """
+    integrals: List[ElectronicIntegrals] = []
+    integrals.append(OneBodyElectronicIntegrals(ElectronicBasis.SO, one_body_integrals))
+    if two_body_integrals is not None:
+        integrals.append(TwoBodyElectronicIntegrals(ElectronicBasis.SO, two_body_integrals))
+
+    prop = IntegralProperty("", integrals)
+
+    fermionic_op = prop.second_q_ops()[0]
+
+    return fermionic_op

qiskit_nature/problems/second_quantization/electronic/builders/hopping_ops_builder.py

@@ -12,8 +12,6 @@
 
 """Utility methods to build fermionic hopping operators."""
 
-# TODO: re-implement these as properties?
-
 from typing import cast, Callable, Dict, List, Tuple, Union
 
 from qiskit.opflow import PauliSumOp