def plane_wave_kinetic(grid: Grid,
spinless: bool = False,
e_cutoff: Optional[float] = None) -> FermionOperator:
"""Return the kinetic energy operator in the plane wave basis.
Args:
grid (openfermion.utils.Grid): The discretization to use.
spinless (bool): Whether to use the spinless model or not.
e_cutoff (float): Energy cutoff.
Returns:
FermionOperator: The kinetic momentum operator.
"""
# Initialize.
operator = FermionOperator()
spins = [None] if spinless else [0, 1]
# Loop once through all plane waves.
for momenta_indices in grid.all_points_indices():
momenta = grid.momentum_vector(momenta_indices)
coefficient = momenta.dot(momenta) / 2.
# Energy cutoff.
if e_cutoff is not None and coefficient > e_cutoff:
continue
# Loop over spins.
for spin in spins:
orbital = grid.orbital_id(momenta_indices, spin)
# Add interaction term.
operators = ((orbital, 1), (orbital, 0))
operator += FermionOperator(operators, coefficient)
return operator
def test_hf_state_plane_wave_basis_lowest_single_determinant_state(self):
grid_length = 7
dimension = 1
spinless = True
n_particles = 4
length_scale = 2.0
grid = Grid(dimension, grid_length, length_scale)
hamiltonian = jellium_model(grid, spinless)
hamiltonian_sparse = get_sparse_operator(hamiltonian)
hf_state = hartree_fock_state_jellium(grid,
n_particles,
spinless,
plane_wave=True)
HF_energy = expectation(hamiltonian_sparse, hf_state)
for occupied_orbitals in permutations([1] * n_particles + [0] *
(grid_length - n_particles)):
state_index = numpy.sum(2**numpy.array(occupied_orbitals))
HF_competitor = numpy.zeros(2**grid_length)
HF_competitor[state_index] = 1.0
self.assertLessEqual(HF_energy,
expectation(hamiltonian_sparse, HF_competitor))
def test_hf_state_energy_same_in_plane_wave_and_dual_basis(self):
grid_length = 4
dimension = 1
wigner_seitz_radius = 10.0
spinless = False
n_orbitals = grid_length**dimension
if not spinless:
n_orbitals *= 2
n_particles = n_orbitals // 2
length_scale = wigner_seitz_length_scale(wigner_seitz_radius,
n_particles, dimension)
grid = Grid(dimension, grid_length, length_scale)
hamiltonian = jellium_model(grid, spinless)
hamiltonian_dual_basis = jellium_model(grid, spinless, plane_wave=False)
# Get the Hamiltonians as sparse operators.
hamiltonian_sparse = get_sparse_operator(hamiltonian)
hamiltonian_dual_sparse = get_sparse_operator(hamiltonian_dual_basis)
hf_state = hartree_fock_state_jellium(grid,
n_particles,
spinless,
plane_wave=True)
hf_state_dual = hartree_fock_state_jellium(grid,
n_particles,
spinless,
plane_wave=False)
E_HF_plane_wave = expectation(hamiltonian_sparse, hf_state)
E_HF_dual = expectation(hamiltonian_dual_sparse, hf_state_dual)
self.assertAlmostEqual(E_HF_dual, E_HF_plane_wave)
def test_hf_state_energy_close_to_ground_energy_at_high_density(self):
grid_length = 8
dimension = 1
spinless = True
n_particles = grid_length**dimension // 2
# High density -> small length_scale.
length_scale = 0.25
grid = Grid(dimension, grid_length, length_scale)
hamiltonian = jellium_model(grid, spinless)
hamiltonian_sparse = get_sparse_operator(hamiltonian)
hf_state = hartree_fock_state_jellium(grid,
n_particles,
spinless,
plane_wave=True)
restricted_hamiltonian = jw_number_restrict_operator(
hamiltonian_sparse, n_particles)
E_g = get_ground_state(restricted_hamiltonian)[0]
E_HF_plane_wave = expectation(hamiltonian_sparse, hf_state)
self.assertAlmostEqual(E_g, E_HF_plane_wave, places=5)
def test_jellium_hamiltonian_correctly_broken_up(self):
grid = Grid(2, 3, 1.)
hamiltonian = jellium_model(grid, spinless=True, plane_wave=False)
potential_terms, kinetic_terms = (
diagonal_coulomb_potential_and_kinetic_terms_as_arrays(hamiltonian)
)
potential = sum(potential_terms, FermionOperator.zero())
kinetic = sum(kinetic_terms, FermionOperator.zero())
true_potential = dual_basis_jellium_model(grid,
spinless=True,
kinetic=False)
true_kinetic = dual_basis_jellium_model(grid,
spinless=True,
potential=False)
for i in range(count_qubits(true_kinetic)):
coeff = true_kinetic.terms.get(((i, 1), (i, 0)))
if coeff:
true_kinetic -= FermionOperator(((i, 1), (i, 0)), coeff)
true_potential += FermionOperator(((i, 1), (i, 0)), coeff)
self.assertEqual(potential, true_potential)
self.assertEqual(kinetic, true_kinetic)
def dual_basis_external_potential(
grid: Grid,
geometry: List[Tuple[str, Tuple[Union[int, float], Union[int, float],
Union[int, float]]]],
spinless: bool,
non_periodic: bool = False,
period_cutoff: Optional[float] = None) -> FermionOperator:
"""Return the external potential in the dual basis of arXiv:1706.00023.
The external potential resulting from electrons interacting with nuclei
in the plane wave dual basis. Note that a cos term is used which is
strictly only equivalent under aliasing in odd grids, and amounts
to the addition of an extra term to make the diagonals real on even
grids. This approximation is not expected to be significant and allows
for use of even and odd grids on an even footing.
Args:
grid (Grid): The discretization to use.
geometry: A list of tuples giving the coordinates of each atom.
example is [('H', (0, 0, 0)), ('H', (0, 0, 0.7414))].
Distances in atomic units. Use atomic symbols to specify atoms.
spinless (bool): Whether to use the spinless model or not.
non_periodic (bool): If the system is non-periodic, default to False.
period_cutoff (float): Period cutoff, default to
grid.volume_scale() ** (1. / grid.dimensions)
Returns:
FermionOperator: The dual basis operator.
"""
prefactor = -4.0 * np.pi / grid.volume_scale()
if non_periodic and period_cutoff is None:
period_cutoff = grid.volume_scale()**(1. / grid.dimensions)
operator = None
if spinless:
spins = [None]
else:
spins = [0, 1]
for pos_indices in grid.all_points_indices():
coordinate_p = grid.position_vector(pos_indices)
for nuclear_term in geometry:
coordinate_j = np.array(nuclear_term[1], float)
for momenta_indices in grid.all_points_indices():
momenta = grid.momentum_vector(momenta_indices)
momenta_squared = momenta.dot(momenta)
if momenta_squared == 0:
continue
cos_index = momenta.dot(coordinate_j - coordinate_p)
coefficient = (prefactor / momenta_squared *
md.periodic_hash_table[nuclear_term[0]] *
np.cos(cos_index))
for spin_p in spins:
orbital_p = grid.orbital_id(pos_indices, spin_p)
operators = ((orbital_p, 1), (orbital_p, 0))
if operator is None:
operator = FermionOperator(operators, coefficient)
else:
operator += FermionOperator(operators, coefficient)
return operator
def test_inverse_fourier_transform_2d(self):
grid = Grid(dimensions=2, scale=1.5, length=3)
spinless = True
geometry = [('H', (0, 0)), ('H', (0.5, 0.8))]
h_plane_wave = plane_wave_hamiltonian(grid, geometry, spinless, True)
h_dual_basis = plane_wave_hamiltonian(grid, geometry, spinless, False)
h_dual_basis_t = inverse_fourier_transform(h_dual_basis, grid, spinless)
self.assertEqual(normal_ordered(h_dual_basis_t),
normal_ordered(h_plane_wave))
def test_inverse_fourier_transform_1d(self):
grid = Grid(dimensions=1, scale=1.5, length=4)
spinless_set = [True, False]
geometry = [('H', (0,)), ('H', (0.5,))]
for spinless in spinless_set:
h_plane_wave = plane_wave_hamiltonian(grid, geometry, spinless,
True)
h_dual_basis = plane_wave_hamiltonian(grid, geometry, spinless,
False)
h_dual_basis_t = inverse_fourier_transform(h_dual_basis, grid,
spinless)
self.assertEqual(normal_ordered(h_dual_basis_t),
normal_ordered(h_plane_wave))
def test_fourier_transform(self):
for length in [2, 3]:
grid = Grid(dimensions=1, scale=1.5, length=length)
spinless_set = [True, False]
geometry = [('H', (0.1,)), ('H', (0.5,))]
for spinless in spinless_set:
h_plane_wave = plane_wave_hamiltonian(grid, geometry, spinless,
True)
h_dual_basis = plane_wave_hamiltonian(grid, geometry, spinless,
False)
h_plane_wave_t = fourier_transform(h_plane_wave, grid, spinless)
self.assertEqual(normal_ordered(h_plane_wave_t),
normal_ordered(h_dual_basis))
# Verify that all 3 are Hermitian
plane_wave_operator = get_sparse_operator(h_plane_wave)
dual_operator = get_sparse_operator(h_dual_basis)
plane_wave_t_operator = get_sparse_operator(h_plane_wave_t)
self.assertTrue(is_hermitian(plane_wave_operator))
self.assertTrue(is_hermitian(dual_operator))
self.assertTrue(is_hermitian(plane_wave_t_operator))
def jellium_model(grid: Grid,
spinless: bool = False,
plane_wave: bool = True,
include_constant: bool = False,
e_cutoff: float = None,
non_periodic: bool = False,
period_cutoff: Optional[float] = None) -> FermionOperator:
"""Return jellium Hamiltonian as FermionOperator class.
Args:
grid (openfermion.utils.Grid): The discretization to use.
spinless (bool): Whether to use the spinless model or not.
plane_wave (bool): Whether to return in momentum space (True)
or position space (False).
include_constant (bool): Whether to include the Madelung constant.
Note constant is unsupported for non-uniform, non-cubic cells with
ions.
e_cutoff (float): Energy cutoff.
non_periodic (bool): If the system is non-periodic, default to False.
period_cutoff (float): Period cutoff, default to
grid.volume_scale() ** (1. / grid.dimensions).
Returns:
FermionOperator: The Hamiltonian of the model.
"""
if plane_wave:
hamiltonian = plane_wave_kinetic(grid, spinless, e_cutoff)
hamiltonian += plane_wave_potential(grid, spinless, e_cutoff,
non_periodic, period_cutoff)
else:
hamiltonian = dual_basis_jellium_model(grid, spinless, True, True,
include_constant, non_periodic,
period_cutoff)
# Include the Madelung constant if requested.
if include_constant:
# TODO: Check for other unit cell shapes
hamiltonian += (FermionOperator.identity() *
(2.8372 / grid.volume_scale()**(1. / grid.dimensions)))
return hamiltonian
def hypercube_grid_with_given_wigner_seitz_radius_and_filling(
dimension: int,
grid_length: int,
wigner_seitz_radius: float,
filling_fraction: float = 0.5,
spinless: bool = True) -> Grid:
"""Return a Grid with the same number of orbitals along each dimension
with the specified Wigner-Seitz radius.
Args:
dimension (int): The number of spatial dimensions.
grid_length (int): The number of orbitals along each dimension.
wigner_seitz_radius (float): The Wigner-Seitz radius per particle,
in Bohr.
filling_fraction (float): The average spin-orbital occupation.
Specifies the number of particles (rounding down).
spinless (boolean): Whether to give the system without or with spin.
"""
if filling_fraction > 1:
raise ValueError("filling_fraction cannot be greater than 1.")
n_qubits = grid_length**dimension
if not spinless:
n_qubits *= 2
n_particles = int(numpy.floor(n_qubits * filling_fraction))
if not n_particles:
raise ValueError(
"filling_fraction too low for number of orbitals specified by "
"other parameters.")
# Compute appropriate length scale.
length_scale = wigner_seitz_length_scale(wigner_seitz_radius, n_particles,
dimension)
return Grid(dimension, grid_length, length_scale)
def jordan_wigner_dual_basis_hamiltonian(
grid: Grid,
geometry: Optional[List[Tuple[str, Tuple[Union[int, float],
Union[int, float],
Union[int, float]]]]] = None,
spinless: bool = False,
include_constant: bool = False) -> QubitOperator:
"""Return the dual basis Hamiltonian as QubitOperator.
Args:
grid (Grid): The discretization to use.
geometry: A list of tuples giving the coordinates of each atom.
example is [('H', (0, 0, 0)), ('H', (0, 0, 0.7414))].
Distances in atomic units. Use atomic symbols to specify atoms.
spinless (bool): Whether to use the spinless model or not.
include_constant (bool): Whether to include the Madelung constant.
Returns:
hamiltonian (QubitOperator)
"""
if (geometry is not None) and (include_constant is True):
raise ValueError('Constant term unsupported for non-uniform systems')
jellium_op = jordan_wigner_dual_basis_jellium(grid, spinless,
include_constant)
if geometry is None:
return jellium_op
for item in geometry:
if len(item[1]) != grid.dimensions:
raise ValueError("Invalid geometry coordinate.")
if item[0] not in md.periodic_hash_table:
raise ValueError("Invalid nuclear element.")
n_orbitals = grid.num_points
volume = grid.volume_scale()
if spinless:
n_qubits = n_orbitals
else:
n_qubits = 2 * n_orbitals
prefactor = -2 * np.pi / volume
external_potential = QubitOperator()
for k_indices in grid.all_points_indices():
momenta = grid.momentum_vector(k_indices)
momenta_squared = momenta.dot(momenta)
if momenta_squared == 0:
continue
for p in range(n_qubits):
index_p = grid.grid_indices(p, spinless)
coordinate_p = grid.position_vector(index_p)
for nuclear_term in geometry:
coordinate_j = np.array(nuclear_term[1], float)
cos_index = momenta.dot(coordinate_j - coordinate_p)
coefficient = (prefactor / momenta_squared *
md.periodic_hash_table[nuclear_term[0]] *
np.cos(cos_index))
external_potential += (QubitOperator(
(), coefficient) - QubitOperator(
((p, 'Z'), ), coefficient))
return jellium_op + external_potential
def plane_wave_potential(
grid: Grid,
spinless: bool = False,
e_cutoff: float = None,
non_periodic: bool = False,
period_cutoff: Optional[float] = None) -> FermionOperator:
"""Return the e-e potential operator in the plane wave basis.
Args:
grid (Grid): The discretization to use.
spinless (bool): Whether to use the spinless model or not.
e_cutoff (float): Energy cutoff.
non_periodic (bool): If the system is non-periodic, default to False.
period_cutoff (float): Period cutoff, default to
grid.volume_scale() ** (1. / grid.dimensions).
Returns:
operator (FermionOperator)
"""
# Initialize.
prefactor = 2. * numpy.pi / grid.volume_scale()
operator = FermionOperator((), 0.0)
spins = [None] if spinless else [0, 1]
if non_periodic and period_cutoff is None:
period_cutoff = grid.volume_scale()**(1. / grid.dimensions)
# Pre-Computations.
shifted_omega_indices_dict = {}
shifted_indices_minus_dict = {}
shifted_indices_plus_dict = {}
orbital_ids = {}
for indices_a in grid.all_points_indices():
shifted_omega_indices = [
j - grid.length[i] // 2 for i, j in enumerate(indices_a)
]
shifted_omega_indices_dict[indices_a] = shifted_omega_indices
shifted_indices_minus_dict[indices_a] = {}
shifted_indices_plus_dict[indices_a] = {}
for indices_b in grid.all_points_indices():
shifted_indices_minus_dict[indices_a][indices_b] = tuple([
(indices_b[i] - shifted_omega_indices[i]) % grid.length[i]
for i in range(grid.dimensions)
])
shifted_indices_plus_dict[indices_a][indices_b] = tuple([
(indices_b[i] + shifted_omega_indices[i]) % grid.length[i]
for i in range(grid.dimensions)
])
orbital_ids[indices_a] = {}
for spin in spins:
orbital_ids[indices_a][spin] = grid.orbital_id(indices_a, spin)
# Loop once through all plane waves.
for omega_indices in grid.all_points_indices():
shifted_omega_indices = shifted_omega_indices_dict[omega_indices]
# Get the momenta vectors.
momenta = grid.momentum_vector(omega_indices)
momenta_squared = momenta.dot(momenta)
# Skip if momentum is zero.
if momenta_squared == 0:
continue
# Energy cutoff.
if e_cutoff is not None and momenta_squared / 2. > e_cutoff:
continue
# Compute coefficient.
coefficient = prefactor / momenta_squared
if non_periodic:
coefficient *= 1.0 - numpy.cos(
period_cutoff * numpy.sqrt(momenta_squared))
for grid_indices_a in grid.all_points_indices():
shifted_indices_d = (
shifted_indices_minus_dict[omega_indices][grid_indices_a])
for grid_indices_b in grid.all_points_indices():
shifted_indices_c = (
shifted_indices_plus_dict[omega_indices][grid_indices_b])
# Loop over spins.
for spin_a in spins:
orbital_a = orbital_ids[grid_indices_a][spin_a]
orbital_d = orbital_ids[shifted_indices_d][spin_a]
for spin_b in spins:
orbital_b = orbital_ids[grid_indices_b][spin_b]
orbital_c = orbital_ids[shifted_indices_c][spin_b]
# Add interaction term.
if ((orbital_a != orbital_b)
and (orbital_c != orbital_d)):
operators = ((orbital_a, 1), (orbital_b, 1),
(orbital_c, 0), (orbital_d, 0))
operator += FermionOperator(operators, coefficient)
# Return.
return operator
def jordan_wigner_dual_basis_jellium(
grid: Grid,
spinless: bool = False,
include_constant: bool = False) -> QubitOperator:
"""Return the jellium Hamiltonian as QubitOperator in the dual basis.
Args:
grid (Grid): The discretization to use.
spinless (bool): Whether to use the spinless model or not.
include_constant (bool): Whether to include the Madelung constant.
Note constant is unsupported for non-uniform, non-cubic cells with
ions.
Returns:
hamiltonian (QubitOperator)
"""
# Initialize.
n_orbitals = grid.num_points
volume = grid.volume_scale()
if spinless:
n_qubits = n_orbitals
else:
n_qubits = 2 * n_orbitals
hamiltonian = QubitOperator()
# Compute vectors.
momentum_vectors = {}
momenta_squared_dict = {}
for indices in grid.all_points_indices():
momenta = grid.momentum_vector(indices)
momentum_vectors[indices] = momenta
momenta_squared_dict[indices] = momenta.dot(momenta)
# Compute the identity coefficient and the coefficient of local Z terms.
identity_coefficient = 0.
z_coefficient = 0.
for k_indices in grid.all_points_indices():
momenta = momentum_vectors[k_indices]
momenta_squared = momenta.dot(momenta)
if momenta_squared == 0:
continue
identity_coefficient += momenta_squared / 2.
identity_coefficient -= (numpy.pi * float(n_orbitals) /
(momenta_squared * volume))
z_coefficient += numpy.pi / (momenta_squared * volume)
z_coefficient -= momenta_squared / (4. * float(n_orbitals))
if spinless:
identity_coefficient /= 2.
# Add identity term.
identity_term = QubitOperator((), identity_coefficient)
hamiltonian += identity_term
# Add local Z terms.
for qubit in range(n_qubits):
qubit_term = QubitOperator(((qubit, 'Z'), ), z_coefficient)
hamiltonian += qubit_term
# Add ZZ terms and XZX + YZY terms.
zz_prefactor = numpy.pi / volume
xzx_yzy_prefactor = .25 / float(n_orbitals)
for p in range(n_qubits):
index_p = grid.grid_indices(p, spinless)
position_p = grid.position_vector(index_p)
for q in range(p + 1, n_qubits):
index_q = grid.grid_indices(q, spinless)
position_q = grid.position_vector(index_q)
difference = position_p - position_q
skip_xzx_yzy = not spinless and (p + q) % 2
# Loop through momenta.
zpzq_coefficient = 0.
term_coefficient = 0.
for k_indices in grid.all_points_indices():
momenta = momentum_vectors[k_indices]
momenta_squared = momenta_squared_dict[k_indices]
if momenta_squared == 0:
continue
cos_difference = numpy.cos(momenta.dot(difference))
zpzq_coefficient += (zz_prefactor * cos_difference /
momenta_squared)
if skip_xzx_yzy:
continue
term_coefficient += (xzx_yzy_prefactor * cos_difference *
momenta_squared)
# Add ZZ term.
qubit_term = QubitOperator(((p, 'Z'), (q, 'Z')), zpzq_coefficient)
hamiltonian += qubit_term
# Add XZX + YZY term.
if skip_xzx_yzy:
continue
z_string = tuple((i, 'Z') for i in range(p + 1, q))
xzx_operators = ((p, 'X'), ) + z_string + ((q, 'X'), )
yzy_operators = ((p, 'Y'), ) + z_string + ((q, 'Y'), )
hamiltonian += QubitOperator(xzx_operators, term_coefficient)
hamiltonian += QubitOperator(yzy_operators, term_coefficient)
# Include the Madelung constant if requested.
if include_constant:
# TODO Generalize to other cells
hamiltonian += (QubitOperator(
(), ) * (2.8372 / grid.volume_scale()**(1. / grid.dimensions)))
# Return Hamiltonian.
return hamiltonian
def dual_basis_jellium_model(
grid: Grid,
spinless: bool = False,
kinetic: bool = True,
potential: bool = True,
include_constant: bool = False,
non_periodic: bool = False,
period_cutoff: Optional[float] = None) -> FermionOperator:
"""Return jellium Hamiltonian in the dual basis of arXiv:1706.00023
Args:
grid (Grid): The discretization to use.
spinless (bool): Whether to use the spinless model or not.
kinetic (bool): Whether to include kinetic terms.
potential (bool): Whether to include potential terms.
include_constant (bool): Whether to include the Madelung constant.
Note constant is unsupported for non-uniform, non-cubic cells with
ions.
non_periodic (bool): If the system is non-periodic, default to False.
period_cutoff (float): Period cutoff, default to
grid.volume_scale() ** (1. / grid.dimensions).
Returns:
operator (FermionOperator)
"""
# Initialize.
n_points = grid.num_points
position_prefactor = 2.0 * numpy.pi / grid.volume_scale()
operator = FermionOperator()
spins = [None] if spinless else [0, 1]
if potential and non_periodic and period_cutoff is None:
period_cutoff = grid.volume_scale()**(1.0 / grid.dimensions)
# Pre-Computations.
position_vectors = {}
momentum_vectors = {}
momenta_squared_dict = {}
orbital_ids = {}
for indices in grid.all_points_indices():
position_vectors[indices] = grid.position_vector(indices)
momenta = grid.momentum_vector(indices)
momentum_vectors[indices] = momenta
momenta_squared_dict[indices] = momenta.dot(momenta)
orbital_ids[indices] = {}
for spin in spins:
orbital_ids[indices][spin] = grid.orbital_id(indices, spin)
# Loop once through all lattice sites.
grid_origin = (0, ) * grid.dimensions
coordinates_origin = position_vectors[grid_origin]
for grid_indices_b in grid.all_points_indices():
coordinates_b = position_vectors[grid_indices_b]
differences = coordinates_b - coordinates_origin
# Compute coefficients.
kinetic_coefficient = 0.
potential_coefficient = 0.
for momenta_indices in grid.all_points_indices():
momenta = momentum_vectors[momenta_indices]
momenta_squared = momenta_squared_dict[momenta_indices]
if momenta_squared == 0:
continue
cos_difference = numpy.cos(momenta.dot(differences))
if kinetic:
kinetic_coefficient += (cos_difference * momenta_squared /
(2. * float(n_points)))
if potential:
potential_coefficient += (position_prefactor * cos_difference /
momenta_squared)
for grid_indices_shift in grid.all_points_indices():
# Loop over spins and identify interacting orbitals.
orbital_a = {}
orbital_b = {}
shifted_index_1 = tuple([
(grid_origin[i] + grid_indices_shift[i]) % grid.length[i]
for i in range(grid.dimensions)
])
shifted_index_2 = tuple([
(grid_indices_b[i] + grid_indices_shift[i]) % grid.length[i]
for i in range(grid.dimensions)
])
for spin in spins:
orbital_a[spin] = orbital_ids[shifted_index_1][spin]
orbital_b[spin] = orbital_ids[shifted_index_2][spin]
if kinetic:
for spin in spins:
operators = ((orbital_a[spin], 1), (orbital_b[spin], 0))
operator += FermionOperator(operators, kinetic_coefficient)
if potential:
for sa in spins:
for sb in spins:
if orbital_a[sa] == orbital_b[sb]:
continue
operators = ((orbital_a[sa], 1), (orbital_a[sa], 0),
(orbital_b[sb], 1), (orbital_b[sb], 0))
operator += FermionOperator(operators,
potential_coefficient)
# Include the Madelung constant if requested.
if include_constant:
# TODO: Check for other unit cell shapes
operator += (FermionOperator.identity() *
(2.8372 / grid.volume_scale()**(1. / grid.dimensions)))
# Return.
return operator