|
"""Make CSVs for numerical data. |
|
|
|
Some data can be slow to process and it is better to write them into a CSV file before |
|
plotting, so that we don't need to wait for a long time during plotting. Data included: |
|
|
|
- Energy result from neural network and ED with different number of electrons in 1/3. |
|
- Ground state energy, quasiparticle/quasihole energy, electron population on the LLL, |
|
and overlap with the Laughlin wavefunction with different kappa in 1/3 filling. |
|
""" |
|
|
|
import os |
|
from pathlib import Path |
|
|
|
os.environ["JAX_PLATFORMS"] = "cpu" |
|
|
|
|
|
import numpy as np |
|
import pandas as pd |
|
from deephall.loss import iqr_clip_real |
|
from puwr import tauint |
|
from uncertainties import ufloat, umath |
|
|
|
DATA_PATH = Path(__file__).parent / "data" |
|
|
|
|
|
def correct_energy(kinetic, potential, N, Q, R, nu, q=0, kappa=1): |
|
|
|
potential -= kappa * (N**2 - q**2) / 2 / R |
|
|
|
energy_in_au = ( |
|
(kinetic - N / 2 * Q / R**2 + potential) * np.sqrt(2 * Q * nu / N) / N |
|
) |
|
|
|
energy_in_ell = energy_in_au * R / np.sqrt(Q) / kappa |
|
return energy_in_ell |
|
|
|
|
|
def ed_energy(ed_output, N, Q, R, nu, q=0): |
|
return correct_energy(N / 2, ed_output / 2, N, Q, R, nu, q) |
|
|
|
|
|
def energy_vs_n(): |
|
data = {"n": [6, 7, 8, 9, 10, 11, 12], "energy": [], "std": [], "ed": []} |
|
for n in data["n"]: |
|
flux = 3 * (n - 1) |
|
netobs_ckpt = DATA_PATH / f"n{n}l{flux}/k1/energy-100k/netobs_ckpt_001999.npz" |
|
with netobs_ckpt.open("rb") as f, np.load(f) as npf: |
|
energy = correct_energy( |
|
npf["values/kinetic"], |
|
npf["values/potential"], |
|
*(n, flux / 2, np.sqrt(flux / 2)), |
|
nu=1 / 3, |
|
).real |
|
mean, std, *_ = tauint([[iqr_clip_real(energy, scale=3)]], 0) |
|
data["energy"].append(mean) |
|
data["std"].append(std) |
|
ed_n = [6, 7, 8, 9, 10, 11] |
|
ed_output = [ |
|
7.7432698280425, |
|
10.121045415564, |
|
12.725298638045, |
|
15.542042784237, |
|
18.559733276244, |
|
21.768350529899, |
|
] |
|
data["ed"] = [ |
|
ed_energy(e, n, 3 * (n - 1) / 2, np.sqrt(3 * (n - 1) / 2), 1 / 3) |
|
for n, e in zip(ed_n, ed_output) |
|
] + [np.nan] |
|
return pd.DataFrame(data) |
|
|
|
|
|
def llm_1_3(): |
|
data = { |
|
"kappa": [0.5, 1, 3, 10], |
|
"energy": [], |
|
"energy_std": [], |
|
"qp_energy": [], |
|
"qp_energy_std": [], |
|
"qh_energy": [], |
|
"qh_energy_std": [], |
|
"gap": [], |
|
"gap_std": [], |
|
"overlap": [], |
|
"overlap_std": [], |
|
"n_LLL": [], |
|
"n_LLL_std": [], |
|
} |
|
for kappa in data["kappa"]: |
|
netobs_ckpt = DATA_PATH / f"n6l14/k{kappa}/energy/netobs_ckpt_001999.npz" |
|
with netobs_ckpt.open("rb") as f, np.load(f) as npf: |
|
qp_energy = correct_energy( |
|
npf["values/kinetic"], |
|
npf["values/potential"], |
|
*(6, 14 / 2, np.sqrt(14 / 2)), |
|
nu=1 / 3, |
|
kappa=kappa, |
|
q=1 / 3, |
|
).real |
|
qp_energy_mean, qp_energy_std, *_ = tauint([[iqr_clip_real(qp_energy)]], 0) |
|
data["qp_energy"].append(qp_energy_mean) |
|
data["qp_energy_std"].append(qp_energy_std) |
|
netobs_ckpt = DATA_PATH / f"n6l15/k{kappa}/energy/netobs_ckpt_001999.npz" |
|
with netobs_ckpt.open("rb") as f, np.load(f) as npf: |
|
energy = correct_energy( |
|
npf["values/kinetic"], |
|
npf["values/potential"], |
|
*(6, 15 / 2, np.sqrt(15 / 2)), |
|
nu=1 / 3, |
|
kappa=kappa, |
|
).real |
|
energy_mean, energy_std, *_ = tauint([[iqr_clip_real(energy)]], 0) |
|
data["energy"].append(energy_mean) |
|
data["energy_std"].append(energy_std) |
|
netobs_ckpt = DATA_PATH / f"n6l16/k{kappa}/energy/netobs_ckpt_001999.npz" |
|
with netobs_ckpt.open("rb") as f, np.load(f) as npf: |
|
qh_energy = correct_energy( |
|
npf["values/kinetic"], |
|
npf["values/potential"], |
|
*(6, 16 / 2, np.sqrt(16 / 2)), |
|
nu=1 / 3, |
|
kappa=kappa, |
|
q=1 / 3, |
|
).real |
|
qh_energy_mean, qh_energy_std, *_ = tauint([[iqr_clip_real(qh_energy)]], 0) |
|
data["qh_energy"].append(qh_energy_mean) |
|
data["qh_energy_std"].append(qh_energy_std) |
|
|
|
gap_mean, gap_std, *_ = tauint( |
|
[[6 * iqr_clip_real(qp_energy + qh_energy - 2 * energy)]], 0 |
|
) |
|
data["gap"].append(gap_mean) |
|
data["gap_std"].append(gap_std) |
|
|
|
netobs_ckpt = DATA_PATH / f"n6l15/k{kappa}/overlap/netobs_ckpt_000199.npz" |
|
with netobs_ckpt.open("rb") as f, np.load(f) as npf: |
|
overlap_num_real, overlap_num_real_std, *_ = tauint( |
|
[[npf["values/ratio"].real]], 0 |
|
) |
|
overlap_num_imag, overlap_num_imag_std, *_ = tauint( |
|
[[npf["values/ratio"].imag]], 0 |
|
) |
|
overlap_den, overlap_den_std, *_ = tauint([[npf["values/ratio_square"]]], 0) |
|
overlap = umath.sqrt( |
|
( |
|
ufloat(overlap_num_real, overlap_num_real_std) ** 2 |
|
+ ufloat(overlap_num_imag, overlap_num_imag_std) ** 2 |
|
) |
|
/ ufloat(overlap_den, overlap_den_std) |
|
) |
|
data["overlap"].append(overlap.n) |
|
data["overlap_std"].append(overlap.s) |
|
netobs_ckpt = DATA_PATH / f"n6l15/k{kappa}/1rdm/netobs_ckpt_019999.npz" |
|
with netobs_ckpt.open("rb") as f, np.load(f) as npf: |
|
trace = np.trace(npf["values/one_rdm"], axis1=1, axis2=2) |
|
mean, std, *_ = tauint([[trace.real]], 0) |
|
data["n_LLL"].append(mean) |
|
data["n_LLL_std"].append(std) |
|
return pd.DataFrame(data) |
|
|
|
|
|
if __name__ == "__main__": |
|
energy_vs_n().to_csv(open(DATA_PATH / "energy_vs_n.csv", "w"), index=False) |
|
llm_1_3().to_csv(open(DATA_PATH / "llm_1_3.csv", "w"), index=False) |
|
|
