def test_wigner_seitz_radius_2d(self):
     wigner_seitz_radius = 0.5
     n_particles = 3
     two_d_test = wigner_seitz_length_scale(wigner_seitz_radius,
                                            n_particles, 2)**2.
     self.assertAlmostEqual(
         two_d_test, n_particles * numpy.pi * wigner_seitz_radius**2.)
 def test_wigner_seitz_radius_1d(self):
     wigner_seitz_radius = 3.17
     n_particles = 20
     one_d_test = wigner_seitz_length_scale(wigner_seitz_radius,
                                            n_particles, 1)
     self.assertAlmostEqual(one_d_test,
                            n_particles * 2. * wigner_seitz_radius)
示例#3
0
def dual_basis_jellium_hamiltonian(grid_length, dimension=3,
                                   wigner_seitz_radius=10., n_particles=None,
                                   spinless=True):
    """Return the jellium Hamiltonian with the given parameters.

    Args:
        grid_length (int): The number of spatial orbitals per dimension.
        dimension (int): The dimension of the system.
        wigner_seitz_radius (float): The radius per particle in Bohr.
        n_particles (int): The number of particles in the system.
                           Defaults to half filling if not specified.
    """
    n_qubits = grid_length ** dimension
    if not spinless:
        n_qubits *= 2

    if n_particles is None:
        # Default to half filling fraction.
        n_particles = n_qubits // 2

    if not (0 <= n_particles <= n_qubits):
        raise ValueError('n_particles must be between 0 and the number of'
                         ' spin-orbitals.')

    # Compute appropriate length scale.
    length_scale = wigner_seitz_length_scale(
        wigner_seitz_radius, n_particles, dimension)

    grid = Grid(dimension, grid_length, length_scale)
    hamiltonian = jellium_model(grid, spinless=spinless, plane_wave=False)
    hamiltonian = normal_ordered(hamiltonian)
    hamiltonian.compress()
    return hamiltonian
 def test_wigner_seitz_radius_6d(self):
     wigner_seitz_radius = 5.
     n_particles = 42
     six_d_test = wigner_seitz_length_scale(wigner_seitz_radius,
                                            n_particles, 6)**6
     self.assertAlmostEqual(
         six_d_test,
         n_particles * (numpy.pi**3 / 6 * wigner_seitz_radius**6))
 def test_wigner_seitz_radius_3d(self):
     wigner_seitz_radius = 4.6
     n_particles = 37
     three_d_test = wigner_seitz_length_scale(wigner_seitz_radius,
                                              n_particles, 3)**3.
     self.assertAlmostEqual(
         three_d_test,
         n_particles * (4. * numpy.pi / 3. * wigner_seitz_radius**3.))
 def test_wigner_seitz_radius_bad_dimension_not_positive(self):
     with self.assertRaises(ValueError):
         wigner_seitz_length_scale(3, 2, dimension=0)