5. operators¶
5.1. O¶
Overlap operator.
Python | Julia |
---|---|
1def O(atoms, W):
2 return atoms.Omega * W
| 1function op_O(atoms::Atoms, W::Matrix{ComplexF64})
2 return atoms.Omega .* W
3end
|
5.2. L¶
Laplacian operator.
Python | Julia |
---|---|
1def L(atoms, W):
2 if len(W) == len(atoms.G2c):
3 G2 = atoms.G2c[:, None]
4 else:
5 G2 = atoms.G2[:, None]
6 return -atoms.Omega * G2 * W
| 1function op_L(atoms::Atoms, W::Matrix{ComplexF64})
2 if size(W)[1] == length(atoms.G2c)
3 G2 = atoms.G2c
4 else
5 G2 = atoms.G2
6 end
7 return -atoms.Omega .* G2 .* W
8end
|
5.3. Linv¶
Inverse Laplacian operator.
Python | Julia |
---|---|
1def Linv(atoms, W):
2 out = np.empty_like(W, dtype=complex)
3 with np.errstate(divide="ignore", invalid="ignore"):
4 if W.ndim == 1:
5 out = W / atoms.G2 / -atoms.Omega
6 out[0] = 0
7 else:
8 G2 = atoms.G2[:, None]
9 out = W / G2 / -atoms.Omega
10 out[0, :] = 0
11 return out
| 1function op_Linv(atoms::Atoms, W::Array{ComplexF64})
2 out = W ./ atoms.G2 ./ -atoms.Omega
3 out[1] = 0.0
4 return out
5end
6function op_Linv(atoms::Atoms, W::Matrix{ComplexF64})
7 out = W ./ atoms.G2 ./ -atoms.Omega
8 out[1, :] .= 0.0
9 return out
10end
|
5.4. I¶
Backwards transformation from reciprocal space to real-space.
Python | Julia |
---|---|
1def I(atoms, W):
2 n = np.prod(atoms.s)
3 if len(W) == len(atoms.G2):
4 Wfft = W
5 else:
6 if W.ndim == 1:
7 Wfft = np.zeros(n, dtype=complex)
8 else:
9 Wfft = np.zeros((n, atoms.Nstate), dtype=complex)
10 Wfft[atoms.active] = W
11
12 if W.ndim == 1:
13 Wfft = Wfft.reshape(atoms.s)
14 Finv = np.fft.ifftn(Wfft).ravel()
15 else:
16 Wfft = Wfft.reshape(np.append(atoms.s, atoms.Nstate))
17 Finv = np.fft.ifftn(Wfft, axes=(0, 1, 2)).reshape((n, atoms.Nstate))
18 return Finv * n
| 1function op_I(atoms::Atoms, W::Array{ComplexF64})
2 n = prod(atoms.s)
3 if size(W)[1] == length(atoms.G2)
4 Wfft = W
5 else
6 Wfft = convert(Array{ComplexF64}, atoms.active)
7 Wfft[Wfft.!=0] = W
8 end
9 Wfft = reshape(Wfft, atoms.s[1], atoms.s[2], atoms.s[3])
10 Finv = vec(ifft(Wfft))
11 return Finv .* n
12end
13function op_I(atoms::Atoms, W::Matrix{ComplexF64})
14 Finv = zeros(ComplexF64, length(atoms.G2), size(W)[2])
15 for i = 1:size(W)[2]
16 Finv[:, i] = op_I(atoms, W[:, i])
17 end
18 return Finv
19end
|
5.5. J¶
Forward transformation from real-space to reciprocal space.
Python | Julia |
---|---|
1def J(atoms, W):
2 n = np.prod(atoms.s)
3 if W.ndim == 1:
4 Wfft = W.reshape(atoms.s)
5 F = np.fft.fftn(Wfft).ravel()
6 else:
7 Wfft = W.reshape(np.append(atoms.s, atoms.Nstate))
8 F = np.fft.fftn(Wfft, axes=(0, 1, 2)).reshape((n, atoms.Nstate))
9 return F / n
| 1function op_J(atoms::Atoms, W::Array{ComplexF64})
2 n = prod(atoms.s)
3 Wfft = reshape(W, atoms.s[1], atoms.s[2], atoms.s[3])
4 Finv = vec(fft(Wfft))
5 return Finv ./ n
6end
7function op_J(atoms::Atoms, W::Matrix{ComplexF64})
8 Finv = zeros(ComplexF64, length(atoms.G2), size(W)[2])
9 for i = 1:size(W)[2]
10 Finv[:, i] = op_J(atoms, W[:, i])
11 end
12 return Finv
13end
|
5.6. Idag¶
Conjugated backwards transformation from real-space to reciprocal space.
Python | Julia |
---|---|
1def Idag(atoms, W):
2 n = np.prod(atoms.s)
3 F = J(atoms, W)
4 F = F[atoms.active]
5 return F * n
| 1function op_Idag(atoms::Atoms, W::Array{ComplexF64})
2 n = prod(atoms.s)
3 F = op_J(atoms, W)
4 F = F[atoms.active[:, 1]]
5 return F .* n
6end
7function op_Idag(atoms::Atoms, W::Matrix{ComplexF64})
8 F = zeros(ComplexF64, length(atoms.G2c), size(W)[2])
9 for i = 1:size(W)[2]
10 F[:, i] = op_Idag(atoms, W[:, i])
11 end
12 return F
13end
|
5.7. Jdag¶
Conjugated forward transformation from reciprocal space to real-space.
Python | Julia |
---|---|
1def Jdag(atoms, W):
2 n = np.prod(atoms.s)
3 Finv = I(atoms, W)
4 return Finv / n
| 1function op_Jdag(atoms::Atoms, W::Array{ComplexF64})
2 n = prod(atoms.s)
3 Finv = op_I(atoms, W)
4 return Finv ./ n
5end
6function op_Jdag(atoms::Atoms, W::Matrix{ComplexF64})
7 n = prod(atoms.s)
8 Finv = op_I(atoms, W)
9 return Finv ./ n
10end
|