Add missing black settings

pyproject.toml

@@ -0,0 +1,3 @@
+[tool.black]
+line-length = 100
+target-version = ['py36', 'py37', 'py38', 'py39']

qiskit_nature/algorithms/excited_states_solvers/excited_states_eigensolver.py

@@ -112,8 +112,6 @@ def solve(
         eigenstate_result.raw_result = raw_es_result
         eigenstate_result.eigenenergies = raw_es_result.eigenvalues
         eigenstate_result.eigenstates = raw_es_result.eigenstates
-        eigenstate_result.aux_operator_eigenvalues = (
-            raw_es_result.aux_operator_eigenvalues
-        )
+        eigenstate_result.aux_operator_eigenvalues = raw_es_result.aux_operator_eigenvalues
         result = problem.interpret(eigenstate_result)
         return result

qiskit_nature/algorithms/excited_states_solvers/qeom.py

@@ -72,8 +72,7 @@ def excitations(self, excitations: Union[str, List[List[int]]]) -> None:
         directly be provided."""
         if isinstance(excitations, str) and excitations not in ["s", "d", "sd"]:
             raise ValueError(
-                "Excitation type must be s (singles), d (doubles) or sd "
-                "(singles and doubles)"
+                "Excitation type must be s (singles), d (doubles) or sd (singles and doubles)"
             )
         self._excitations = excitations
 
@@ -106,9 +105,7 @@ def solve(
         groundstate_result = self._gsc.solve(problem)
 
         # 2. Prepare the excitation operators
-        self._untapered_qubit_op_main = self._gsc._qubit_converter.map(
-            problem.second_q_ops()[0]
-        )
+        self._untapered_qubit_op_main = self._gsc._qubit_converter.map(problem.second_q_ops()[0])
         matrix_operators_dict, size = self._prepare_matrix_operators(problem)
 
         # 3. Evaluate eom operators
@@ -130,9 +127,7 @@ def solve(
         ) = self._build_eom_matrices(measurement_results, size)
 
         # 5. solve pseudo-eigenvalue problem
-        energy_gaps, expansion_coefs = self._compute_excitation_energies(
-            m_mat, v_mat, q_mat, w_mat
-        )
+        energy_gaps, expansion_coefs = self._compute_excitation_energies(m_mat, v_mat, q_mat, w_mat)
 
         qeom_result = QEOMResult()
         qeom_result.ground_state_raw_result = groundstate_result.raw_result
@@ -149,16 +144,12 @@ def solve(
 
         eigenstate_result = EigenstateResult()
         eigenstate_result.eigenstates = groundstate_result.eigenstates
-        eigenstate_result.aux_operator_eigenvalues = (
-            groundstate_result.aux_operator_eigenvalues
-        )
+        eigenstate_result.aux_operator_eigenvalues = groundstate_result.aux_operator_eigenvalues
         eigenstate_result.raw_result = qeom_result
 
         eigenstate_result.eigenenergies = np.append(
             groundstate_result.eigenenergies,
-            np.asarray(
-                [groundstate_result.eigenenergies[0] + gap for gap in energy_gaps]
-            ),
+            np.asarray([groundstate_result.eigenenergies[0] + gap for gap in energy_gaps]),
         )
 
         result = problem.interpret(eigenstate_result)
@@ -245,9 +236,7 @@ def _build_one_sector(available_hopping_ops, untapered_op, z2_symmetries):
             z2_symmetries = Z2Symmetries([], [], [])
 
         if not z2_symmetries.is_empty():
-            combinations = itertools.product(
-                [1, -1], repeat=len(z2_symmetries.symmetries)
-            )
+            combinations = itertools.product([1, -1], repeat=len(z2_symmetries.symmetries))
             for targeted_tapering_values in combinations:
                 logger.info(
                     "In sector: (%s)",
@@ -268,9 +257,7 @@ def _build_one_sector(available_hopping_ops, untapered_op, z2_symmetries):
 
         else:
             # untapered_qubit_op is a PauliSumOp and should not be exposed.
-            _build_one_sector(
-                hopping_operators, self._untapered_qubit_op_main, z2_symmetries
-            )
+            _build_one_sector(hopping_operators, self._untapered_qubit_op_main, z2_symmetries)
 
         return all_matrix_operators
 
@@ -339,9 +326,7 @@ def _build_commutator_routine(
 
     def _build_eom_matrices(
         self, gs_results: Dict[str, List[float]], size: int
-    ) -> Tuple[
-        np.ndarray, np.ndarray, np.ndarray, np.ndarray, float, float, float, float
-    ]:
+    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, float, float, float, float]:
         """Constructs the M, V, Q and W matrices from the results on the ground state
 
         Args:

qiskit_nature/algorithms/ground_state_solvers/adapt_vqe.py

@@ -99,9 +99,7 @@ def _compute_gradients(
             vqe.ansatz = self._ansatz
             ansatz_params = vqe.ansatz._parameter_table.keys()
             # construct the expectation operator of the VQE
-            vqe._expect_op = vqe.construct_expectation(
-                ansatz_params, self._main_operator
-            )
+            vqe._expect_op = vqe.construct_expectation(ansatz_params, self._main_operator)
             # evaluate energies
             parameter_sets = theta + [-self._delta] + theta + [self._delta]
             energy_results = vqe._energy_evaluation(np.asarray(parameter_sets))
@@ -179,13 +177,9 @@ def solve(
             vqe = self._solver
 
         if not isinstance(vqe, VQE):
-            raise QiskitNatureError(
-                "The AdaptVQE algorithm requires the use of the VQE solver"
-            )
+            raise QiskitNatureError("The AdaptVQE algorithm requires the use of the VQE solver")
         if not isinstance(vqe.ansatz, UCC):
-            raise QiskitNatureError(
-                "The AdaptVQE algorithm requires the use of the UCC ansatz"
-            )
+            raise QiskitNatureError("The AdaptVQE algorithm requires the use of the UCC ansatz")
 
         # We construct the ansatz once to be able to extract the full set of excitation operators.
         self._ansatz = copy.deepcopy(vqe.ansatz)
@@ -222,8 +216,7 @@ def solve(
                 logger.info(gradlog)
             if np.abs(max_grad[0]) < self._threshold:
                 logger.info(
-                    "Adaptive VQE terminated successfully "
-                    "with a final maximum gradient: %s",
+                    "Adaptive VQE terminated successfully with a final maximum gradient: %s",
                     str(np.abs(max_grad[0])),
                 )
                 threshold_satisfied = True
@@ -263,9 +256,7 @@ def solve(
         elif max_iterations_exceeded:
             finishing_criterion = "Maximum number of iterations reached"
         else:
-            raise QiskitNatureError(
-                "The algorithm finished due to an unforeseen reason!"
-            )
+            raise QiskitNatureError("The algorithm finished due to an unforeseen reason!")
 
         electronic_result = problem.interpret(raw_vqe_result)
 

qiskit_nature/algorithms/ground_state_solvers/ground_state_eigensolver.py

@@ -54,9 +54,7 @@ def solver(self) -> Union[MinimumEigensolver, MinimumEigensolverFactory]:
         return self._solver
 
     @solver.setter
-    def solver(
-        self, solver: Union[MinimumEigensolver, MinimumEigensolverFactory]
-    ) -> None:
+    def solver(self, solver: Union[MinimumEigensolver, MinimumEigensolverFactory]) -> None:
         """Sets the minimum eigensolver or factory."""
         self._solver = solver
 
@@ -129,9 +127,7 @@ def evaluate_operators(
             OperatorBase,
         ],
         operators: Union[PauliSumOp, OperatorBase, list, dict],
-    ) -> Union[
-        Optional[float], List[Optional[float]], Dict[str, List[Optional[float]]]
-    ]:
+    ) -> Union[Optional[float], List[Optional[float]], Dict[str, List[Optional[float]]]]:
         """Evaluates additional operators at the given state.
 
         Args:
@@ -160,18 +156,14 @@ def evaluate_operators(
                 if op is None:
                     results.append(None)
                 else:
-                    results.append(
-                        self._eval_op(state, op, quantum_instance, expectation)
-                    )
+                    results.append(self._eval_op(state, op, quantum_instance, expectation))
         elif isinstance(operators, dict):
             results = {}  # type: ignore
             for name, op in operators.items():
                 if op is None:
                     results[name] = None
                 else:
-                    results[name] = self._eval_op(
-                        state, op, quantum_instance, expectation
-                    )
+                    results[name] = self._eval_op(state, op, quantum_instance, expectation)
         else:
             if operators is None:
                 results = None

qiskit_nature/algorithms/ground_state_solvers/minimum_eigensolver_factories/vqe_ucc_factory.py

@@ -198,9 +198,7 @@ def get_solver(  # type: ignore[override]
 
         initial_state = self.initial_state
         if initial_state is None:
-            initial_state = HartreeFock(
-                num_spin_orbitals, num_particles, qubit_converter
-            )
+            initial_state = HartreeFock(num_spin_orbitals, num_particles, qubit_converter)
 
         ansatz = self.ansatz
         if ansatz is None:

qiskit_nature/algorithms/ground_state_solvers/minimum_eigensolver_factories/vqe_uvcc_factory.py

@@ -189,9 +189,7 @@ def get_solver(  # type: ignore[override]
             by ``transformation``.
         """
 
-        watson_hamiltonian_transformed = cast(
-            WatsonHamiltonian, problem.molecule_data_transformed
-        )
+        watson_hamiltonian_transformed = cast(WatsonHamiltonian, problem.molecule_data_transformed)
         num_modals = problem.num_modals
         num_modes = watson_hamiltonian_transformed.num_modes
 

qiskit_nature/algorithms/pes_samplers/bopes_sampler.py

@@ -77,9 +77,7 @@ def __init__(
                 if not isinstance(self._extrapolator, WindowExtrapolator):
                     raise QiskitNatureError(
                         "If num_bootstrap >= 2 then the extrapolator must be an instance "
-                        "of WindowExtrapolator, got {} instead".format(
-                            self._extrapolator
-                        )
+                        "of WindowExtrapolator, got {} instead".format(self._extrapolator)
                     )
                 self._num_bootstrap = num_bootstrap
                 self._extrapolator.window = num_bootstrap  # window for extrapolator
@@ -176,9 +174,7 @@ def _run_single_point(self, point: float) -> EigenstateResult:
             # Set initial params # if prev_points not empty
             if prev_points:
                 if n_pp <= n_boot:
-                    distances = np.array(point) - np.array(prev_points).reshape(
-                        n_pp, -1
-                    )
+                    distances = np.array(point) - np.array(prev_points).reshape(n_pp, -1)
                     # find min 'distance' from point to previous points
                     min_index = np.argmin(np.linalg.norm(distances, axis=1))
                     # update initial point

qiskit_nature/algorithms/pes_samplers/extrapolator.py

@@ -269,9 +269,7 @@ def extrapolate(
         """
         ret_params = {}
         sorted_points = sorted(points)
-        reference_points = [
-            pt for pt in sorted(param_dict.keys()) if pt < max(sorted_points)
-        ]
+        reference_points = [pt for pt in sorted(param_dict.keys()) if pt < max(sorted_points)]
 
         for bottom_index, bottom in enumerate(reference_points):
             if bottom_index < len(reference_points) - 1:
@@ -340,9 +338,7 @@ class PCAExtrapolator(Extrapolator):
 
     def __init__(
         self,
-        extrapolator: Optional[
-            Union[PolynomialExtrapolator, DifferentialExtrapolator]
-        ] = None,
+        extrapolator: Optional[Union[PolynomialExtrapolator, DifferentialExtrapolator]] = None,
         kernel: Optional[str] = None,
         window: int = 2,
     ) -> None:
@@ -360,9 +356,7 @@ def __init__(
         Raises:
             QiskitNatureError: if kernel is not defined in sklearn module.
         """
-        self._extrapolator = WindowExtrapolator(
-            extrapolator=extrapolator, window=window
-        )
+        self._extrapolator = WindowExtrapolator(extrapolator=extrapolator, window=window)
         self._kernel = kernel
         if self._kernel is None:
             self._pca_model = PCA()
@@ -391,12 +385,9 @@ def extrapolate(
         # run pca fitting and extrapolate in pca space
         self._pca_model.fit(list(param_dict.values()))
         updated_params = {
-            pt: self._pca_model.transform([param_dict[pt]])[0]
-            for pt in list(param_dict.keys())
+            pt: self._pca_model.transform([param_dict[pt]])[0] for pt in list(param_dict.keys())
         }
-        output_params = self._extrapolator.extrapolate(
-            points, param_dict=updated_params
-        )
+        output_params = self._extrapolator.extrapolate(points, param_dict=updated_params)
 
         ret_params = {
             point: self._pca_model.inverse_transform(param) if not param else []
@@ -414,9 +405,7 @@ class SieveExtrapolator(Extrapolator):
 
     def __init__(
         self,
-        extrapolator: Optional[
-            Union[PolynomialExtrapolator, DifferentialExtrapolator]
-        ] = None,
+        extrapolator: Optional[Union[PolynomialExtrapolator, DifferentialExtrapolator]] = None,
         window: int = 2,
         filter_before: bool = True,
         filter_after: bool = True,
@@ -432,9 +421,7 @@ def __init__(
             filter_after: Keyword to perform clustering after extrapolation.
 
         """
-        self._extrapolator = WindowExtrapolator(
-            extrapolator=extrapolator, window=window
-        )
+        self._extrapolator = WindowExtrapolator(extrapolator=extrapolator, window=window)
         self._filter_before = filter_before
         self._filter_after = filter_after
 
@@ -461,27 +448,19 @@ def extrapolate(
         """
         # determine clustering cutoff
         param_arr = np.transpose(list(param_dict.values()))
-        param_averages = np.array(
-            sorted(np.average(np.log10(np.abs(param_arr)), axis=0))
-        )
+        param_averages = np.array(sorted(np.average(np.log10(np.abs(param_arr)), axis=0)))
         gaps = param_averages[1:] - param_averages[:-1]
         max_gap = int(np.argmax(gaps))
-        sieve_cutoff = 10 ** np.average(
-            [param_averages[max_gap], param_averages[max_gap + 1]]
-        )
+        sieve_cutoff = 10 ** np.average([param_averages[max_gap], param_averages[max_gap + 1]])
 
         if self._filter_before:
             filtered_dict = {
                 point: list(map(lambda x: x if np.abs(x) > sieve_cutoff else 0, param))
                 for (point, param) in param_dict.items()
             }
-            output_params = self._extrapolator.extrapolate(
-                points, param_dict=filtered_dict
-            )
+            output_params = self._extrapolator.extrapolate(points, param_dict=filtered_dict)
         else:
-            output_params = self._extrapolator.extrapolate(
-                points, param_dict=param_dict
-            )
+            output_params = self._extrapolator.extrapolate(points, param_dict=param_dict)
 
         if self._filter_after:
             ret_params = cast(

qiskit_nature/algorithms/pes_samplers/potentials/harmonic_potential.py

@@ -122,9 +122,7 @@ def fit(
         # do the Harmonic potential fit here, the order of parameters is
         # [k (Hartrees/(Ang**2)), r_0 (Ang), energy_shift (Hartrees)]
         h_p0 = initial_vals if initial_vals is not None else np.array([0.2, 0.735, 1.5])
-        h_bounds = (
-            bounds_list if bounds_list is not None else ([0, -1, -2], [2, 3.0, 2])
-        )
+        h_bounds = bounds_list if bounds_list is not None else ([0, -1, -2], [2, 3.0, 2])
 
         xdata_fit = xdata
         ydata_fit = ydata
@@ -238,9 +236,7 @@ def vibrational_energy_level(self, n: int) -> float:
         return e_n * const.J_TO_HARTREE
 
     @classmethod
-    def process_fit_data(
-        cls, xdata: List[float], ydata: List[float]
-    ) -> Tuple[list, list]:
+    def process_fit_data(cls, xdata: List[float], ydata: List[float]) -> Tuple[list, list]:
         """
         Mostly for internal use. Preprocesses the data passed to fit_to_data()
             so that only the points around the minimum are fit (which gives
@@ -265,9 +261,7 @@ def process_fit_data(
         # is minimum
         all_of_min = np.array([], dtype=int)
         for i in x_min:
-            all_of_min = np.concatenate(
-                (all_of_min, np.where(xdata_s == xdata_s[i])[0])
-            )
+            all_of_min = np.concatenate((all_of_min, np.where(xdata_s == xdata_s[i])[0]))
         # array of indices where X is equal to the next smaller value
         left_of_min = []
         if min(all_of_min) > 0: