def setUp(self) -> None:
        """Setup expected object."""
        super().setUp()

        driver = GaussianForcesDriver(logfile=self.get_resource_path(
            "test_driver_gaussian_log_C01.txt",
            "drivers/second_quantization/gaussiand"))
        self.expected = driver.run()
        self.expected.basis = HarmonicBasis([3])
    def second_q_ops(self) -> ListOrDictType[SecondQuantizedOp]:
        """Returns the second quantized operators created based on the driver and transformations.

        If the arguments are returned as a `list`, the operators are in the following order: the
        Vibrational Hamiltonian operator, occupied modal operators for each mode.

        The actual return-type is determined by `qiskit_nature.settings.dict_aux_operators`.

        Returns:
            A `list` or `dict` of `SecondQuantizedOp` objects.
        """
        driver_result = self.driver.run()

        if self._legacy_driver:
            self._molecule_data = cast(WatsonHamiltonian, driver_result)
            self._grouped_property = VibrationalStructureDriverResult.from_legacy_driver_result(
                self._molecule_data
            )

            if self._legacy_transform:
                self._molecule_data_transformed = self._transform(self._molecule_data)
                self._grouped_property_transformed = (
                    VibrationalStructureDriverResult.from_legacy_driver_result(
                        self._molecule_data_transformed
                    )
                )

            else:
                self._grouped_property_transformed = self._transform(self._grouped_property)

        else:
            self._grouped_property = driver_result
            self._grouped_property_transformed = self._transform(self._grouped_property)

        self._grouped_property_transformed = cast(
            VibrationalStructureDriverResult, self._grouped_property_transformed
        )

        num_modes = self._grouped_property_transformed.num_modes
        if isinstance(self.num_modals, int):
            num_modals = [self.num_modals] * num_modes
        else:
            num_modals = self.num_modals

        # TODO: expose this as an argument in __init__
        basis = HarmonicBasis(num_modals)
        self._grouped_property_transformed.basis = basis

        second_quantized_ops = self._grouped_property_transformed.second_q_ops()

        return second_quantized_ops
Ejemplo n.º 3
0
    def test_larger_tutorial_qubit_op(self):
        """Test the 3-modal qubit operator generated in the vibrational structure tutorial."""
        num_modes = self.driver_result.num_modes
        num_modals = [3] * num_modes

        vibration_energy = self.driver_result.get_property("VibrationalEnergy")
        vibration_energy.basis = HarmonicBasis(num_modals)

        vibration_op = vibration_energy.second_q_ops()[0]

        mapper = DirectMapper()
        qubit_op = mapper.map(vibration_op)

        self.assertEqual(qubit_op, _num_modals_3_q_op)
Ejemplo n.º 4
0
    def test_mapping(self):
        """Test mapping to qubit operator"""
        num_modes = self.driver_result.num_modes
        num_modals = [2] * num_modes

        vibration_energy = self.driver_result.get_property("VibrationalEnergy")
        vibration_energy.basis = HarmonicBasis(num_modals)

        vibration_op = vibration_energy.second_q_ops()[0]

        mapper = DirectMapper()
        qubit_op = mapper.map(vibration_op)

        self.assertEqual(qubit_op, _num_modals_2_q_op)
Ejemplo n.º 5
0
    def test_mapping(self):
        """Test mapping to qubit operator"""
        with warnings.catch_warnings():
            warnings.filterwarnings("ignore", category=DeprecationWarning)
            driver = GaussianForcesDriver(logfile=self.get_resource_path(
                "CO2_freq_B3LYP_ccpVDZ.log",
                "problems/second_quantization/vibrational/resources",
            ))
            driver_result = driver.run()
        num_modes = driver_result.num_modes
        num_modals = [2] * num_modes

        vibration_energy = driver_result.get_property("VibrationalEnergy")
        vibration_energy.basis = HarmonicBasis(num_modals)

        vibration_op = vibration_energy.second_q_ops()[0]

        mapper = DirectMapper()
        qubit_op = mapper.map(vibration_op)

        self.assertEqual(qubit_op, REFERENCE)